home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games Extra 1996 September / Amiga Games Extra CD-ROM 9-1996.iso / userbox / publicdomain / vim-4.2 / doc / vim_ref.txt < prev    next >
Text File  |  1996-06-17  |  416KB  |  9,856 lines

  1. *vim_ref.txt*   For Vim version 4.2.  Last modification: 1996 June 17
  2.  
  3.  
  4.                  VIM REFERENCE MANUAL
  5.  
  6.                   By Bram Moolenaar
  7.  
  8.  
  9.  
  10. There is a contents listing at the end of this document.
  11.  
  12. This manual mostly assumes that there is only one window.  The commands and
  13. options for multiple windows and buffers are explained in |vim_win.txt|.
  14.  
  15. This manual describes running Vim from a normal terminal or with a terminal
  16. emulator in a window.  See |vim_gui.txt| for the GUI version.
  17.  
  18. You can use tags to jump to the explanation of a subject.  Position the cursor
  19. on an item name between bars (e.g., |intro|) or an option name in single
  20. quotes (e.g., 'textwidth' ) and hit CTRL-].  This mostly also works on a
  21. command in double quotes (e.g., ":buf").  Three special characters in the
  22. names of the tags are not allowed.  They have been replaced with letters:
  23. "bar" for '|', "star" for '*', and "quote" for '"'.
  24.  
  25.                    tag starts with    example
  26.        Normal and Visual mode    nothing        |x|
  27.                   Visual mode    "v_"        |v_u|
  28.               Insert mode    "i_"        |i_<Esc>|
  29.     Command line commands    ":"        |:quit|
  30.      Command line editing    "c_"        |c_<Del>|
  31.       Vim command options    "-"        |-r|
  32.           Vim options    "'"        |'shell'|
  33.  
  34.  
  35. 1. Introduction                        *intro*
  36. ===============
  37.  
  38. Vim stands for Vi IMproved.  It used to be Vi IMitation, but there are so many
  39. improvements that a name change was appropriate.  Vim is a text editor which
  40. includes almost all the commands from the Unix program "Vi" and a lot of new
  41. ones.  It is very useful for editing programs and other 8-bit ASCII text.  All
  42. commands are given with the keyboard.  This has the advantage that you can
  43. keep your fingers on the keyboard and your eyes on the screen.  For those who
  44. want it, there is mouse support and a GUI version with scrollbars and menus
  45. (see |vim_gui.txt|).
  46.  
  47. Throughout this manual the differences between Vi and Vim are mentioned in
  48. curly braces.  See |vim_diff.txt| for a summary of the differences.
  49.  
  50. This manual refers to Vim on various machines.  There may be small differences
  51. between different computers and terminals.  Besides the remarks given in this
  52. document, there is a separate document for each supported system:
  53.       system                see
  54.     Amiga                |vim_ami.txt|
  55.     Archimedes            |vim_arch.txt|
  56.     Atari MiNT                  |vim_mint.txt|
  57.     Macintosh            |vim_mac.txt|
  58.     MS-DOS                |vim_dos.txt|
  59.     OS/2                |vim_os2.txt|
  60.     Unix                |vim_unix.txt|
  61.     Win32: Windows NT / Windows 95    |vim_w32.txt|
  62.  
  63. This manual is a reference for all the Vim commands and options.  This is not
  64. an introduction to the use of Vim.  There are many books on vi that contain a
  65. section for beginners.
  66.  
  67. A summary of this manual can be found in the file "vim_help.txt",
  68. |vim_help.txt|.  It can be accessed from within Vim with the <Help> or <F1>
  69. key and with the command ":help", |:help|.  The 'helpfile' option can be set
  70. to the name of the help file, so you can put it in any place you like.
  71.  
  72.  
  73. 2. Notation                        *notation*
  74. ===========
  75.  
  76. []        Characters in square brackets are optional.
  77.  
  78.                             *count*
  79. [count]        An optional number that may precede the command to multiply
  80.         or iterate the command.  If no number is given, a count of one
  81.         is used, unless otherwise noted.  Note that in this manual the
  82.         [count] is not mentioned in the description of the command,
  83.         but only in the explanation.  This was done to make the
  84.         commands easier to lookup.  If the "sc" option is on
  85.         (|'showcmd'|), the (partially) entered count is shown at the
  86.         bottom of the window.  You can use <Del> to erase the last
  87.         digit (|N<Del>|).
  88.  
  89. ["x]        An optional register designation where text can be stored.
  90.         See |registers|.  The x is a single character between 'a' and
  91.         'z' or 'A' and 'Z' or '"', and in some cases (with the put
  92.         command) between '0' and '9', '%', ':', or '.'.  The uppercase
  93.         and lowercase letters designate the same register, but the
  94.         lowercase letter is used to overwrite the previous register
  95.         contents, while the uppercase letter is used to append to the
  96.         previous register contents.  Without the ""x" or with """",
  97.         the stored text is put into the unnamed register.
  98.  
  99. {}        Curly braces denote parts of the command which must appear,
  100.         but which can take a number of different values.  The
  101.         differences between Vim and Vi are also given in curly braces
  102.         (this will be clear from the context).
  103.  
  104.                             *{motion}*
  105. {motion}    A command that moves the cursor.  See the list in chapter 6,
  106.         |cursor_motions|.  This is used after an operator command
  107.         |operator| to move over the text that is to be operated upon.
  108.         If the motion includes a count and the operator also had a
  109.         count, the two counts are multiplied.  For example: "2d3w"
  110.         deletes six words.  The motion can also be a mouse click.  The
  111.         mouse is currently only supported for MS-DOS, Win32 and xterm
  112.         under Unix.
  113.  
  114.                             *{Visual}*
  115. {Visual}    A piece of text that is started with the "v", "V", or CTRL-V
  116.         command and ended by the cursor position.  This is used
  117.         before an operator command |operator| to highlight the text
  118.         that is to be operated upon.  See the chapter on Visual mode
  119.         |Visual_mode|.
  120.  
  121. <character>    A special character from the table below or a single ASCII
  122.         character.
  123.  
  124. 'character'    A single ASCII character.
  125.  
  126. <char1-char2>    A single character from the range <char1> to <char2>.  For
  127.         example: <a-z> is a lowercase letter.  Multiple ranges may be
  128.         concatenated.  For example, <a-zA-Z0-9> is any alphanumeric
  129.         character.
  130.  
  131. CTRL-{char}    {char} typed as a control character; that is, typing {char}
  132.         while holding the CTRL key down.  The case of {char} does not
  133.         matter; thus CTRL-A and CTRL-a are equivalent.
  134.  
  135. 'option'    An option, or parameter, that can be set to a value, is
  136.         enclosed in single quotes.  See chapter 19, |options|.
  137.  
  138. "command"    In examples, the commands you can type are enclosed in double
  139.         quotes.
  140.  
  141.                                 *key_notation*
  142. notation    meaning            equivalent    decimal value(s)
  143. -----------------------------------------------------------------------
  144. <Nul>        zero            CTRL-@      0 (stored as 10)
  145. <BS>        backspace        CTRL-H      8    *backspace*
  146. <Tab>        tab            CTRL-I      9    *tab*
  147.                             *linefeed*
  148. <NL>        linefeed        CTRL-J     10 (used for <Nul>)
  149.                             *carriage return*
  150. <CR>        carriage return        CTRL-M     13
  151. <Esc>        escape            CTRL-[     27    *escape*
  152. <Space>        space                 32    *space*
  153. <Del>        delete                127
  154.  
  155. <Up>        cursor-up            *cursor-up* *cursor_up*
  156. <Down>        cursor-down            *cursor-down* *cursor_down*
  157. <Left>        cursor-left            *cursor-left* *cursor_left*
  158. <Right>        cursor-right            *cursor-right* *cursor_right*
  159. <S-Up>        shift-cursor-up
  160. <S-Down>    shift-cursor-down
  161. <S-Left>    shift-cursor-left
  162. <S-Right>    shift-cursor-right
  163. <F1> - <F12>    function keys 1 to 12        *function_key* *function-key*
  164. <S-F1> - <S-F12> shift-function keys 1 to 12
  165. <Help>        help key
  166. <Undo>        undo key
  167. <Insert>    insert key
  168. <Home>        home                *home*
  169. <End>        end                *end*
  170. <PageUp>    page-up                *page_up* *page-up*
  171. <PageDown>    page-down            *page_down* *page-down*
  172. <S-...>        shift-key            *shift*
  173. <C-...>        control-key            *control* *ctrl*
  174. <M-...>        alt-key or meta-key        *meta* *alt*
  175. <t_xx>        key with "xx" entry in termcap
  176. -----------------------------------------------------------------------
  177.  
  178. Note: The shifted cursor keys, the help key, and the undo key are only
  179. available on a few terminals.  On the Amiga, shifted function key 10 produces
  180. a code (CSI) that is also used by key sequences.  It will be recognized only
  181. after typing another key.
  182.  
  183. Note: There are two codes for the delete key.  127 is the ASCII value for the
  184. delete key, which is always recognized.  Some delete keys send another value,
  185. in which case this value is obtained from the termcap entry "kD".  Both values
  186. have the same effect.  Also see |:fixdel|.
  187.  
  188.                                 *<>*
  189. Some of the examples are given in the <> notation.  The rules are:
  190.  1.  Any printable characters are typed directly, except backslash and '<'
  191.  2.  A backslash is represented with "\\", double backslash.
  192.  3.  A real '<' is represented with "\<".
  193.  4.  "<key>" means the special key typed.  This is the notation explained in
  194.      the table above.  A few examples:
  195.        <Esc>        Escape key
  196.        <C-G>        CTRL-G
  197.        <Up>            cursor up key
  198.        <C-LeftMouse>    Control- left mouse click
  199.        <S-F11>        Shifted function key 11
  200.        <M-a>        Meta- a  ('a' with bit 8 set)
  201.        <M-A>        Meta- A  ('A' with bit 8 set)
  202.        <t_kd>        "kd" termcap entry (cursor down key)
  203.  
  204. If you want to use this notation in Vim, you have to remove the 'B' flag from
  205. 'cpoptions' and make sure the '<' flag is excluded (it already is by default).
  206.     :set cpo=ceFs
  207. For mapping, abbreviation and menu commands you can then copy-paste the
  208. examples and use them directly.  Or type them literally, including the '<' and
  209. '>' characters.  This does NOT work for other commands, like ":set" and
  210. ":autocmd"!
  211.  
  212.  
  213. 3. Starting Vim                        *starting*
  214. ===============
  215.  
  216. 3.1 Vim arguments                    *vim_arguments*
  217.  
  218. Most often, Vim is started to edit a single file with the command
  219.  
  220.     vim file                    *-vim*
  221.  
  222. More generally, Vim is started with:
  223.  
  224.     vim [options] [arglist]
  225.  
  226. If the arglist is missing, the editor will start with an empty buffer.
  227. Otherwise exactly one out of the following three may be used to choose one
  228. or more files to be edited.
  229.  
  230.                             *-file* *--*
  231. file ..        A list of file names.  The first one will be the current file
  232.         and read into the buffer.  The cursor will be positioned on
  233.         the first line of the buffer.  To avoid a file name starting
  234.         with a '-' being interpreted as an option, precede the arglist
  235.         with "--", e.g.:
  236.             Vim -- -filename
  237.  
  238.                             *-t* *-tag*
  239. -t {tag}    A tag.  "tag" is looked up in the tags file, the associated
  240.         file becomes the current file, and the associated command is
  241.         executed.  Mostly this is used for C programs.  In that case,
  242.         "tag" should be a function name.  The effect is that the file
  243.         containing that function becomes the current file and the
  244.         cursor is positioned on the start of the function (see the
  245.         section on tags, |tags|).
  246.  
  247.                             *-e* *-qf*
  248. -e [errorfile]    QuickFix mode.  The file with the name [errorfile] is read
  249.         and the first error is displayed.  If [errorfile] is not
  250.         given, the 'errorfile' option is used for the file name
  251.         (default "AztecC.Err" for the Amiga, "errors.vim" for other
  252.         systems).  See section 5.5: "using the QuickFix mode",
  253.         |quickfix|.  {not in Vi}
  254.  
  255.                             *startup-options*
  256. The options, if present, must precede the arglist.  The options may be given
  257. in any order.  Single-letter options can be combined after one dash.
  258.  
  259.                             *-+*
  260. +[num]        The cursor will be positioned on line "num" for the first
  261.         file being edited.  If "num" is missing, the cursor will be
  262.         positioned on the last line.
  263.  
  264.                             *-+/*
  265. +/{pat}        The cursor will be positioned on the first line containing
  266.         "pat" in the first file being edited (see the section
  267.         "pattern searches" for the available search patterns,
  268.         |search_pattern|).
  269.  
  270. +{command}                        *-+c* *-c*
  271. -c {command}    "command" will be executed after the first file has been
  272.         read (and after autocommands and modelines for that file have
  273.         been processed).  "command" is interpreted as an Ex command.
  274.         If the "command" contains spaces, it must be enclosed in
  275.         double quotes (this depends on the shell that is used).
  276.         Example: vim "+set si" main.c
  277.  
  278.         Note: You can use only one "+" or "-c" argument in a Vim
  279.         command.
  280.  
  281.                             *-r*
  282. -r        Recovery mode.  Without a file name argument, a list of
  283.         existing swap files is given.  With a file name, a swap file
  284.         is read to recover a crashed editing session.  See the
  285.         chapter "Recovery after a crash", |crash_recovery|.
  286.  
  287.                             *-L*
  288. -L        Same as -r.  {only in some versions of Vi: "List recoverable
  289.         edit sessions"}
  290.  
  291.                             *-v*
  292. -v        View mode.  The 'readonly' option will be set for all the
  293.         files being edited.  You can still edit the buffer, but will
  294.         be prevented from accidentally overwriting a file.  If you
  295.         forgot that you are in View mode and did make some changes,
  296.         you can overwrite a file by adding an exclamation mark to
  297.         the Ex command, as in ":w!".  The 'readonly' option can be
  298.         reset with ":set noro" (see the options chapter, |options|).
  299.         Subsequent edits will not be done in readonly mode.  Calling
  300.         the executable "view" has the same effect as the -v option.
  301.         If your system does not support links and you do not want to
  302.         have the executable twice, you could make an alias: "alias
  303.         view vim -v".  The 'updatecount' option will be set to 10000,
  304.         meaning that the swap file will not be updated automatically
  305.         very often.  {Vi: "ex -v" means to start ex in vi mode.
  306.         "vi -v" does nothing}
  307.  
  308.                             *-R*
  309. -R        Readonly mode.  Same as -v.
  310.  
  311.                             *-b*
  312. -b        Binary mode.  The 'textauto', 'textmode', and 'expandtab'
  313.         options will be reset.  The 'textwidth' option is set to 0.
  314.         'modeline' is reset.  The 'binary' option is set.  This is
  315.         done after reading the vimrc/exrc files but before reading
  316.         any file in the arglist.  See also 5.6:
  317.         "Editing binary files", |edit_binary|.  {not in Vi}
  318.  
  319.                             *-l*
  320. -l        Lisp mode.  Sets the 'lisp' and 'showmatch' options on.
  321.  
  322.                             *-H*
  323. -H        Hebrew mode.  Sets the 'hkmap' and 'rightleft' options on.
  324.         (Only when compiled with LEFTRIGHT defined, otherwise Vim
  325.         gives an error message and exits).  {not in Vi}
  326.  
  327.                             *-n*
  328. -n        No swap file will be used.  Recovery after a crash will be
  329.         impossible.  Handy if you want to view or edit a file on a
  330.         very slow medium (e.g., a floppy).  Can also be done with
  331.         ":set updatecount=0".  You can switch it on again by setting
  332.         the 'updatecount' option to some value, e.g., ":set uc=100".
  333.         {not in Vi}
  334.  
  335.                             *-o*
  336. -o[N]        Open N windows.  If [N] is not given, one window is opened
  337.         for every file given as argument.  If there is not enough
  338.         room, only the first few files get a window.  If there are
  339.         more windows than arguments, the last few windows will be
  340.         editing an empty file.  {not in Vi}
  341.  
  342.                             *-T*
  343. -T {terminal}    Set the terminal type to "terminal".  This influences the
  344.         codes that Vim will send to your terminal.  This is normally
  345.         not needed, because Vim will be able to find out what type
  346.         of terminal you are using (See chapter 20, |terminal_info|).
  347.         {not in Vi}
  348.  
  349.                             *-d*
  350. -d {device}    Amiga only: The "device" is opened to be used for editing.
  351.         Normally you would use this to set the window position and
  352.         size: "-d con:x/y/width/height", e.g.,
  353.         "-d con:30/10/600/150".  But you can also use it to start
  354.         editing on another device, e.g., AUX:.  {not in Vi}
  355.  
  356.                             *-x*
  357. -x        Amiga only: Do not restart Vim to open a new window.  This
  358.         option should be used when Vim is started by a program that
  359.         will wait for the edit session to finish (e.g., mail or
  360.         readnews).  See section 3.3, |amiga_window|.  {not in Vi}
  361.  
  362.                             *-f*
  363. -f        GUI only: Do not disconnect from the program that started Vim.
  364.         'f' stands for "foreground".  If omitted, the GUI forks a new
  365.         process and exits the current one.  "-f" should be used when
  366.         gvim is started by a program that will wait for the edit
  367.         session to finish (e.g., mail or readnews).  If you want gvim
  368.         never to fork, include 'f' in 'guioptions'.  Careful: You can
  369.         use "-gf" to start the GUI in the foreground, but "-fg" is
  370.         used to specify the foreground color.  {not in Vi} |gui_fork|
  371.  
  372.                             *-u*
  373. -u {vimrc}    The file "vimrc" is read for initializations.  Other
  374.         initializations are skipped; see |initialization|.  This can
  375.         be used to start Vim in a special mode, with special
  376.         mappings and settings.  A shell alias can be used to make
  377.         this easy to use.  For example:
  378.             "alias vimc vim -u ~/.c_vimrc !*".
  379.         Also consider using autocommands; see |autocommand|.
  380.         When {vimrc} is equal to "NONE" (all uppercase), all
  381.         initializations from files and environment variables are
  382.         skipped.  {not in Vi}
  383.  
  384.                             *-i*
  385. -i {viminfo}    The file "viminfo" is used instead of the default viminfo
  386.         file.  If the name "NONE" is used (all uppercase), no viminfo
  387.         file is read or written, even if 'viminfo' is set or when
  388.         ":rv" or ":wv" are used.  See also |viminfo_file|.  {not in Vi}
  389.  
  390.                             *-s*
  391. -s {scriptin}    The script file "scriptin" is read.  The characters in the
  392.         file are interpreted as if you had typed them.  The same can
  393.         be done with the command ":source! {scriptin}".  If the end
  394.         of the file is reached before the editor exits, further
  395.         characters are read from the keyboard.  See also the section
  396.         "complex repeats", |complex_repeat|.  {not in Vi}
  397.  
  398.                             *-w*
  399. -w {scriptout}    All the characters that you type are recorded in the file
  400.         "scriptout", until you exit Vim.  This is useful if you want
  401.         to create a script file to be used with "vim -s" or
  402.         ":source!".  When the "scriptout" file already exists, new
  403.         characters are appended.  See also the section "complex
  404.         repeats", |complex_repeat|.  {not in Vi}
  405.  
  406.                             *-W*
  407. -W {scriptout}    Like -w, but do not append, overwrite an existing file.  {not
  408.         in Vi}
  409.  
  410.                             *-w_nr*
  411. -w{number}    Does nothing.  This was included for Vi-compatibility.  In Vi
  412.         it sets the 'window' option, which is not implemented in Vim.
  413.  
  414. Example for using a script file to change a name in several files:
  415.     Create a file "subs.vi" containing substitute commands and a :wq
  416.     command:
  417.  
  418.         :%s/Jones/Smith/g
  419.         :%s/Allen/Peter/g
  420.         :wq
  421.  
  422.     Execute Vim on all files you want to change:
  423.  
  424.         foreach i ( *.let ) vim -s subs.vi $i
  425.  
  426. If the executable is called "view", Vim will start in Readonly mode.  This is
  427. useful if you can make a hard or symbolic link from "view" to "vim".
  428. Starting in Readonly mode can also be done with "vim -v".
  429.  
  430.  
  431. 3.2 Workbench (Amiga only)                *workbench*
  432.  
  433. Vim can be started from the workbench by clicking on its icon twice.  It will
  434. then start with an empty buffer.
  435.  
  436. Vim can be started to edit one or more files by using a "Project" icon.  The
  437. "Default Tool" of the icon must be the full pathname of the Vim executable.
  438. The name of the ".info" file must be the same as the name of the text file.
  439. By clicking on this icon twice, Vim will be started with the filename as
  440. current filename, which will be read into the buffer (if it exists).  You can
  441. edit multiple files by pressing the shift key while clicking on icons, and
  442. clicking twice on the last one.  The "Default Tool" for all these icons must
  443. be the same.
  444.  
  445. It is not possible to give arguments to Vim, other than filenames, from the
  446. workbench.
  447.  
  448.  
  449. 3.3 Vim window (Amiga only)                *amiga_window*
  450.  
  451. Vim will run in the CLI window where it was started.  If Vim was started with
  452. the "run" or "runback" command, or if Vim was started from the workbench, it
  453. will open a window of its own.
  454.  
  455. Technical detail:
  456.     To open the new window a little trick is used.  As soon as Vim
  457.     recognizes that it does not run in a normal CLI window, it will
  458.     create a script file in "t:".  This script file contains the same
  459.     command as the one Vim was started with, and an "endcli" command.  This
  460.     script file is then executed with a "newcli" command (the "c:run" and
  461.     "c:newcli" commands are required for this to work).  The script file
  462.     will hang around until reboot, or until you delete it.  This method
  463.     is required to get the ":sh" and ":!" commands to work correctly.
  464.     But when Vim was started with the -e option (Quickfix mode) or with
  465.     the -x option, this method is not used.  The reason for this is that
  466.     when a compiler starts Vim with the -e option it will wait for a
  467.     return code.  With the script trick, the compiler cannot get the
  468.     return code.  The -x option can be used when Vim is started by a mail
  469.     program which also waits for the edit session to finish.  As a
  470.     consequence, the ":sh" and ":!" commands are not available when the
  471.     -e or -x option is used.
  472.  
  473. Vim will automatically recognize the window size and react to window
  474. resizing.  Under Amiga DOS 1.3, it is advised to use the fastfonts program,
  475. "FF", to speed up display redrawing.
  476.  
  477.  
  478. 3.4 Initialization                *initialization* *startup*
  479.  
  480. This section is about the non-GUI version of Vim.  See |gui_fork| for
  481. additional initialization when starting the GUI.
  482.  
  483. At startup, Vim checks environment variables and files and sets values
  484. accordingly.  Vim proceeds in this order:
  485.  
  486. 1. Setting the 'shell' option                *SHELL* *COMSPEC*
  487.     The environment variable SHELL, if it exists, is used to set the
  488.     'shell' option.  On MS-DOS and Win32, the COMPSPEC variable is used
  489.     if SHELL is not set.
  490.  
  491. 2. Setting the 'term' option                *TERM*
  492.     The environment variable TERM, if it exists, is used to set the 'term'
  493.     option.
  494.  
  495. 3. Reading Ex commands from environment variables and/or files
  496.     An environment variable is read as one Ex command line, where multiple
  497.     commands must be separated with '|' or "<NL>".
  498.                                 *vimrc* *exrc*
  499.     A file that contains initialization commands is called a "vimrc" file.
  500.     Each line in a vimrc file is executed as an Ex command line.  It is
  501.     sometimes also referred to as "exrc" file.  They are the same type of
  502.     file, but "exrc" is what Vi always used, "vimrc" is a Vim specific
  503.     name.
  504.  
  505.     If Vim was started with "-u filename", the file "filename" is used.
  506.     All following initializations until 4. are skipped.
  507.     "vim -u NONE" can be used to skip these initializations.  |-u|
  508.  
  509.      a. For Unix the system vimrc file is read for initializations.  The path
  510.     of this file is shown with the ":version" command.
  511.  
  512.               *VIMINIT* *.vimrc* *_vimrc* *EXINIT* *.exrc* *_exrc*
  513.      b. Four places are searched for initializations.  The first that exists
  514.     is used, the others are ignored.
  515.     -  The environment variable VIMINIT
  516.     -  The user vimrc file:
  517.             "~/.vimrc"       (for Unix and OS/2)
  518.             "s:.vimrc"     (for Amiga)
  519.             "$VIM\_vimrc"  (for MS-DOS and Win32)
  520.         Note: For Unix, OS/2 and Amiga, when ".vimrc" does not exist,
  521.         "_vimrc" is also tried, in case an MS-DOS compatible file
  522.         system is used.  For MS-DOS and Win32 ".vimrc" is checked
  523.         after "_vimrc", in case long file names are used.
  524.         If $VIM is not set, $HOME is used.
  525.     -  The environment variable EXINIT
  526.     -  The user exrc file:
  527.             "~/.exrc"      (for Unix and OS/2)
  528.                 "s:.exrc"      (for Amiga)
  529.             "$VIM\_exrc"   (for MS-DOS and Win32).
  530.  
  531.      c. If the 'exrc' option is on (which is not the default), the current
  532.     directory is searched for three files.  The first that exists is used,
  533.     the others are ignored.
  534.     -  The file ".vimrc" (for Unix, Amiga and OS/2)
  535.                 "_vimrc" (for MS-DOS and Win32)
  536.     -  The file "_vimrc" (for Unix, Amiga and OS/2)
  537.                 ".vimrc" (for MS-DOS and Win32)
  538.     -  The file ".exrc"  (for Unix, Amiga and OS/2)
  539.                 "_exrc"  (for MS-DOS and Win32)
  540.  
  541. 4. Setting 'shellpipe' and 'shellredir'
  542.     The 'shellpipe' and 'shellredir' options are set according to the
  543.     value of the 'shell' option, unless they have been set before.
  544.     This means that Vim will figure out the values of 'shellpipe' and
  545.     'shellredir' for you, unless you have set them yourself.
  546.  
  547. 5. Read the viminfo file
  548.     If the 'viminfo' option is not empty, the viminfo file is read.  The
  549.     default is empty, so 'viminfo' must have been set by one of the
  550.     previous initializations.  See |viminfo_file|.
  551.  
  552. Some hints on using initializations:
  553.  
  554. Standard setup:
  555. Create a vimrc file to set the default settings and mappings for all your edit
  556. sessions.  Put it in a place so that it will be found by 3b:
  557.     ~/.vimrc    (Unix and OS/2)
  558.     s:.vimrc    (Amiga)
  559.     $VIM\_vimrc    (MS-DOS and Win32)
  560.  
  561. Local setup:
  562. Put all commands that you need for editing a specific directory only into a
  563. vimrc file and place it in that directory under the name ".vimrc" ("_vimrc"
  564. for MS-DOS and Win32).  NOTE: To make Vim look for these special files you
  565. have to turn on the option 'exrc'.  See |trojan_horse| too.
  566.  
  567. System setup:
  568. This only applies if you are managing a Unix system with several users and
  569. want to set the defaults for all users.  Create a vimrc file with commands
  570. for default settings and mappings and put it in the place that is given with
  571. the ":version" command.
  572.  
  573. Saving the current state of Vim to a file:
  574. Whenever you have changed values of options or when you have created a
  575. mapping, then you may want to save them in a vimrc file for later use.  See
  576. |save_settings| about saving the current state of settings to a file.
  577.  
  578. Avoiding setup problems for Vi users:
  579. Vi uses the variable EXINIT and the file "~/.exrc".  So if you do not want to
  580. interfere with Vi, then use the variable VIMINIT and the file "vimrc" instead.
  581.  
  582. Amiga environment variables:
  583. On the Amiga, two types of environment variables exist.  The ones set with the
  584. DOS 1.3 (or later) setenv command are recognized.  See the AmigaDos 1.3
  585. manual.  The environment variables set with the old Manx Set command (before
  586. version 5.0) are not recognized.
  587.  
  588. MS-DOS line separators:
  589. On MS-DOS-like systems (MS-DOS itself, Win32, and OS/2), Vim assumes that all
  590. the vimrc files have <CR><NL> pairs as line separators.  This will give
  591. problems if you have a file with only <NL>s and have a line like
  592. ":map xx yy^M".  The trailing ^M will be ignored.
  593.  
  594. Avoiding trojan horses:                    *trojan_horse*
  595. While reading the "vimrc" or the "exrc" file in the current directory, some
  596. commands can be disabled for security reasons by setting the 'secure' option.
  597. Otherwise it would be possible that you accidentally use a vimrc file that
  598. somebody else created and contains nasty commands.  The disabled commands are
  599. the ones that start a shell, the ones that write to a file, and ":autocmd".
  600. The ":map" commands are echoed, so you can see which keys are being mapped.
  601.     If you want Vim to execute all commands in a local vimrc file, you
  602. can reset the 'secure' option in the EXINIT or VIMINIT environment variable or
  603. in the global "exrc" or "vimrc" file.  This is not possible in "vimrc" or
  604. "exrc" in the current directory, for obvious reasons.
  605.     On Unix systems, this only happens if you are not the owner of the
  606. vimrc file.  Warning: If you unpack an archive that contains a vimrc or exrc
  607. file, it will be owned by you.  You won't have the security protection.  Check
  608. the vimrc file before you start Vim in that directory, or reset the 'exrc'
  609. option.  Some Unix systems allow a user to do "chown" on a file.  This makes
  610. it possible for another user to create a nasty vimrc and make you the owner.
  611. Be careful!
  612.  
  613.                             *slow_start*
  614. If Vim takes a long time to start up, there may be a few causes:
  615. - If the Unix version was compiled with the GUI and/or X11 (check the output
  616.   of ":version" for "+GUI" and "+X11"), it may need to load shared libraries
  617.   and connect to the X11 server.  Try compiling a version with GUI and X11
  618.   disabled.  This also should make the executable smaller.
  619. - If you have "viminfo" enabled, the loading of the viminfo file may take a
  620.   while.  You can find out if this is the problem by disabling viminfo for a
  621.   moment (use the Vim argument "-i NONE", |-i|).  Try reducing the number of
  622.   lines stored in a register with ":set viminfo='20\"50".
  623.                               |viminfo_file|.
  624.  
  625.  
  626. 3.5 Suspending                        *suspend*
  627.  
  628.                             *CTRL-Z* *v_CTRL-Z*
  629. CTRL-Z            On Unix systems: Suspend Vim.  On other systems:
  630.             start a new shell (like ":sh").  Same as ":stop".
  631.             Works in Normal and in Visual mode.  In Insert and
  632.             Command-line mode, the CTRL-Z is inserted as a normal
  633.             character.
  634.  
  635.  
  636. :sus[pend][!]    or            *:sus* *:suspend* *:st* *:stop*
  637. :st[op][!]        Suspend the editor.  If the '!' is not given, the
  638.             buffer was changed, 'autowrite' is set, and a filename
  639.             is known, the buffer will be written.
  640.  
  641. On many Unix systems, it is possible to suspend Vim with CTRL-Z.  This is only
  642. possible in Normal and Visual mode (see next chapter, |vim_modes|).  Vim will
  643. continue if you make it the foreground job again.  On other systems, CTRL-Z
  644. will start a new shell.  This is the same as the ":sh" command.  Vim will
  645. continue if you exit from the shell.
  646.  
  647.  
  648. 3.6 The viminfo file                    *viminfo_file*
  649.  
  650. The viminfo file is used to store:
  651. - The command line history.
  652. - The search string history.
  653. - Contents of registers.
  654. - Marks for several files.
  655. - File marks, pointing to locations in files.
  656. - Last search/substitute pattern (for 'n' and '&').
  657.  
  658. The viminfo file is only supported when Vim has been compiled with VIMINFO
  659. defined.  If the output of ":version" contains "+viminfo" then it was; if it
  660. contains "-viminfo" then it wasn't.  By default, VIMINFO is defined.
  661.  
  662. When Vim is started and the 'viminfo' option is non-empty, the contents of
  663. the viminfo file are read and the info can be used in the appropriate places.
  664. The marks are not read in at startup (but file marks are).  See
  665. |initialization| for how to set the 'viminfo' option upon startup.
  666.  
  667. When Vim is exited and 'viminfo' is non-empty, the info is stored in the
  668. viminfo file (it's actually merged with the existing one, if one exists).  The
  669. 'viminfo' option is a string containing information about what info should be
  670. stored, and contains limits on how much should be stored (see 'viminfo').
  671.  
  672. Marks are stored for each file separately.  When a file is read and 'viminfo'
  673. is non-empty, the marks for that file are read from the viminfo file.  NOTE:
  674. The marks are only written when exiting Vim, which is fine because marks are
  675. remembered for all the files you have opened in the current editing session,
  676. unless ":bdel" is used.  If you want to save the marks for a file that you are
  677. about to abandon with ":bdel", use ":wv".  The '[' and ']' marks are not
  678. stored, but the '"' mark is.  The '"' mark is very useful for jumping to the
  679. cursor position when the file was last exited.  No marks are saved for files
  680. that start with any string given with the "r" flag in 'viminfo'.  This can be
  681. used to avoid saving marks for files on removable media (for MS-DOS you would
  682. use "ra:,rb:", for Amiga "rdf0:,rdf1:,rdf2:").
  683.  
  684.                             *viminfo_file_marks*
  685. Uppercase marks ('A to 'Z) are stored when writing the viminfo file.  The
  686. numbered marks ('0 to '9) are a bit special.  When the viminfo file is written
  687. (when exiting or with the ":wviminfo" command), '0 is set to the current cursor
  688. position and file.  The old '0 is moved to '1, '1 to '2, etc.  This
  689. resembles what happens with the "1 to "9 delete registers.  If the current
  690. cursor position is already present in '0 to '9, it is moved to '0, to avoid
  691. having the same position twice.  The result is that with "'0", you can jump
  692. back to the file and line where you exited Vim.
  693.  
  694. The default name of the viminfo file is "$HOME/.viminfo" for Unix,
  695. "s:.viminfo" for Amiga, "$VIM\viminfo" for MS-DOS and Win32.  The "-i" Vim
  696. argument can be used to set another file name, |-i|.  For the commands below,
  697. another file name can be given, overriding the default and the name given with
  698. "-i".  When the file name given with the "-i" Vim argument is "NONE"
  699. (all uppercase), no viminfo file is ever read or written.
  700.  
  701. Two commands can be used to read and write the viminfo file manually.  This
  702. can be used to exchange registers between two running Vim programs: First
  703. type ":wv" in one and then ":rv" in the other.  Note that if the register
  704. already contained something, then ":rv!" would be required.  Also note
  705. however that this means everything will be overwritten with information from
  706. the first Vim, including the command line history, etc.
  707.  
  708. The viminfo file itself can be edited by hand too, although we suggest you
  709. start with an existing one to get the format right.  It is reasonably
  710. self-explanatory once you're in there.  This can be useful in order to
  711. create a second file, say "~/.my_viminfo" which could contain certain
  712. settings that you always want when you first start Vim.  For example, you
  713. can preload registers with particular data, or put certain commands in the
  714. command line history.  A line in your .vimrc file like
  715.     rviminfo! ~/.my_viminfo
  716. can be used to load this information.  You could even have different viminfos
  717. for different types of files (e.g., C code) and load them based on the file
  718. name, using the ":autocmd" command (see |:autocmd|).
  719.  
  720.                            *:rv* *:rviminfo*
  721. :rv[iminfo][!] [file]    Read from viminfo file [file] (default: see above).
  722.             If [!] is given, then any information that is
  723.             already set (registers, marks, etc.) will be
  724.             overwritten.  {not in Vi}
  725.  
  726.                            *:wv* *:wviminfo*
  727. :wv[iminfo][!] [file]    Write to viminfo file [file] (default: see above).
  728.             The information in the file is first read in to make
  729.             a merge between old and new info.  When [!] is used,
  730.             the old information is not read first, only the
  731.             internal info is written.  If 'viminfo' is empty, marks
  732.             for up to 100 files will be written.  {not in Vi}
  733.  
  734.  
  735. 4. Modes                        *vim_modes*
  736. ========
  737.  
  738. 4.1 Introduction
  739.  
  740. Vim has four BASIC modes:
  741.  
  742. Normal mode        In Normal mode you can enter all the editor
  743.             commands.  If you start the editor you are in this
  744.             mode (unless you have set the 'insertmode' option,
  745.             see below).  This is also known as command mode.
  746.  
  747. Visual mode        This is like Normal mode, but the movement commands
  748.             extend a highlighted area.  When a non-movement
  749.             command is used, it is executed for the highlighted
  750.             area.  See |Visual_mode|.
  751.  
  752. Insert mode        In Insert mode the text you type is inserted into the
  753.             buffer.  If the 'showmode' option is on (which is
  754.             default), the string "-- INSERT --" is shown at the
  755.             bottom of the window.  |mode_ins_repl|
  756.  
  757. Command-line mode    In Command-line mode you can enter one line of text
  758.             at the bottom of the window.  This is for the Ex
  759.             commands, ":", the pattern search commands, "?" and
  760.             "/", and the filter command, "!".  |mode_cmdline|
  761.  
  762. There are two ADDITIONAL modes:
  763.  
  764. Replace mode        Replace mode is a special case of Insert mode.  You
  765.             can do the same things as in Insert mode, but for
  766.             each character you enter, one character of the existing
  767.             text is deleted.  If the 'showmode' option is on,
  768.             (which is the default), the string "-- REPLACE --" is
  769.             shown at the bottom of the window.  |replace_mode|
  770.  
  771. Insert command mode    Entered when CTRL-O given in Insert mode.  This is
  772.             like Normal mode, but after executing one command Vim
  773.             returns to Insert mode.  The string "-- (insert) --"
  774.             is shown at the bottom of the window.
  775.  
  776. 4.2 Switching from mode to mode                *mode_switching*
  777.  
  778. If for any reason you do not know which mode you are in, you can always get
  779. back to Normal mode by typing <Esc> twice.  You will know you are back in
  780. Normal mode when you see the screen flash or hear the bell after you type
  781. <Esc>.
  782.  
  783. - go from Normal mode to Visual mode by giving one of the commands "vV^V"
  784. - go from Normal mode to Insert mode by giving one of the commands
  785.   "iIaAoOcCsS".
  786. - go from Normal mode to Replace mode with the "R" command (not the "r"
  787.   command!).
  788. - go from Normal mode to Command-line mode with the one of the commands
  789.   ":/?!".
  790.  
  791.                             *i_esc*
  792. - go from Insert or Replace mode to Normal mode with <Esc> (twice in some
  793.   rare cases).
  794. - go from Visual mode to Normal mode by giving a non-movement command, which
  795.   causes the command to be executed, or by hitting <Esc> or 'v', which does
  796.   nothing.
  797. - go from Command-line mode to Normal mode by:
  798.    - hitting <CR> or <NL>, which causes the entered command to be executed
  799.    - deleting the complete line (e.g., with CTRL-U) and giving a final <BS>
  800.    - hitting CTRL-C or <Esc>, which quits the command line without executing
  801.      the command.
  802.   In the last case <Esc> may be the character defined with the 'wildchar'
  803.   option, in which case it will start command line completion.  You can ignore
  804.   that and type <Esc> again.  {Vi: when hitting <Esc> the command line is
  805.   executed.  This is unexpected for most people; therefore it was changed in
  806.   Vim.  But when the <Esc> is part of a mapping, the command line is executed.
  807.   If you want the Vi behaviour also when typing <Esc>, use ":cmap ^V<Esc>
  808.   ^V^M"}
  809.  
  810. - go from Insert mode to Replace mode by hitting <Insert>.
  811. - go from Replace mode to Insert mode by hitting <Insert>.
  812. - go from Visual mode to Command-line mode by hitting ':'.  The line numbers
  813.   of the highlighted area will be inserted in the command line.
  814.  
  815. If the 'insertmode' option is on, editing a file will start in Insert mode.
  816.  
  817.  
  818. 4.3 Insert and Replace mode                *mode_ins_repl*
  819.  
  820. If you are working in a special language mode when inserting text, see the
  821. 'langmap' option, |'langmap'|, on how to avoid switching this mode on and off
  822. all the time.
  823.  
  824. 4.3.1 special keys                    *ins_special_keys*
  825.  
  826. In Insert and Replace mode, the following characters have a special meaning;
  827. other characters are inserted directly.  To insert one of these special
  828. characters into the buffer, precede it with CTRL-V.  To insert a <Nul>
  829. character use "CTRL-V CTRL-@" or "CTRL-V 000".  On some systems, you have to
  830. use "CTRL-V 003" to insert a CTRL-C.
  831.  
  832. char        action
  833. -----------------------------------------------------------------------
  834.                         *i_CTRL-[* *i_<Esc>*
  835. <Esc> or CTRL-[    End insert or Replace mode, go back to Normal mode.  Finish
  836.         abbreviation.
  837.                         *i_CTRL-C*
  838. CTRL-C        Quit insert mode, go back to Normal mode.  Do not check for
  839.         abbreviations.
  840.  
  841.                         *i_CTRL-@*
  842. CTRL-@        Insert previously inserted text and stop insert.  {Vi: only
  843.         when typed as first char, only up to 128 chars}
  844.                         *i_CTRL-A*
  845. CTRL-A        Insert previously inserted text.  {not in Vi}
  846.  
  847.                         *i_CTRL-H* *i_<BS>*
  848. <BS> or CTRL-H    Delete the character before the cursor (see below).
  849.         See |:fixdel| if your <BS> does not do what you want.
  850.         {Vi: does not delete autoindents}
  851.                         *i_<Del>*
  852. <Del>        Delete the character under the cursor.  If the cursor is at
  853.         the end of the line, and the 'backspace' option is non-zero,
  854.         delete the newline; the next line is appended after the
  855.         current one.  See |:fixdel| if your <Del> key does not do what
  856.         you want.  {not in Vi}
  857.                         *i_CTRL-W*
  858. CTRL-W        Delete the word before the cursor (see below).  See the
  859.         section "word motions", |word_motions|, for the definition of
  860.         a word.
  861.                         *i_CTRL-U*
  862. CTRL-U        Delete all entered characters in the current line (see
  863.         below).
  864.  
  865.                         *i_CTRL-I* *i_<Tab>*
  866. <Tab> or CTRL-I Insert a tab.  If the 'expandtab' option is on, the
  867.         equivalent number of spaces is inserted (use CTRL-V <Tab> to
  868.         avoid the expansion).  See also the 'smarttab' option and
  869.         section 4.3.4, |ins_expandtab|.
  870.                         *i_CTRL-J* *i_<NL>*
  871. <NL> or CTRL-J    Begin new line.
  872.                         *i_CTRL-M* *i_<CR>*
  873. <CR> or CTRL-M    Begin new line.
  874.                         *i_CTRL-K*
  875. CTRL-K {char1} {char2}
  876.         Enter digraph (see 4.7, |digraphs|).  When {char1} is a special
  877.         key, the code for that key is inserted.  Neither char is
  878.         considered for mapping.  {not in Vi}
  879.  
  880. CTRL-N        Find next keyword (see 4.3.6, |i_CTRL-N|).  {not in Vi}
  881. CTRL-P        Find previous keyword (see 4.3.6, |i_CTRL-P|).  {not in Vi}
  882.  
  883. CTRL-R <0-9a-z"%:.->                *i_CTRL-R*
  884.         Insert the contents of register.  Between typing CTRL-R and
  885.         the second character '"' will be displayed to indicate that
  886.         you are expected to enter the name of a register.
  887.         The text is inserted as if you typed it, but mappings and
  888.         abbreviations are not used.  If you have options like
  889.         'textwidth', 'formatoptions', or 'autoindent' set, this will
  890.         influence what will be inserted.  This is different from what
  891.         happens with the "p" command and pasting with the mouse.
  892.         Special registers:
  893.             '"'    the unnamed register, containing the text of
  894.                 the last delete or yank
  895.             '%'    the current file name
  896.             ':'    the last command line
  897.             '.'    the last inserted text
  898.             '-'    the last small (less than a line) delete
  899.         See |registers| about registers.  {not in Vi}
  900.  
  901.                         *i_CTRL-T*
  902. CTRL-T        Insert one shiftwidth of indent at the start of the current
  903.         line.  The indent is always rounded to a 'shiftwidth' (this is
  904.         vi compatible).  {Vi: only when in indent}
  905.                         *i_CTRL-D*
  906. CTRL-D        Delete one shiftwidth of indent at the start of the current
  907.         line.  The indent is always rounded to a 'shiftwidth' (this is
  908.         vi compatible).  {Vi: CTRL-D works only when used after
  909.         autoindent}
  910.                         *i_0_CTRL-D*
  911. 0 CTRL-D    Delete all indent in the current line.  {Vi: CTRL-D works
  912.         only when used after autoindent}
  913.                         *i_^_CTRL-D*
  914. ^ CTRL-D    Delete all indent in the current line.  The indent is
  915.         restored in the next line.  This is useful when inserting a
  916.         label.  {Vi: CTRL-D works only when used after autoindent}
  917.  
  918.                         *i_CTRL-V*
  919. CTRL-V        Insert next non-digit literally.  For special keys, the
  920.         terminal code is inserted.  Up to three digits form the
  921.         decimal value of a single byte (see below |i_CTRL-V_digit|.
  922.         The non-digit and the three digits are not considered for
  923.         mapping.  {Vi: no decimal byte entry}
  924.  
  925.                         *i_CTRL-Q*
  926. CTRL-Q        Same as CTRL-V.
  927.  
  928. CTRL-X        Enter CTRL-X mode.  This is a sub-mode where commands can
  929.         be given to complete words or scroll the window. See below,
  930.         |i_CTRL-X|, and in 4.3.6, |ins_completion|. {not in Vi}
  931.  
  932.                         *i_CTRL-E*
  933. CTRL-E        Insert the character which is below the cursor.  {not in Vi}
  934.                         *i_CTRL-Y*
  935. CTRL-Y        Insert the character which is above the cursor.  {not in Vi}
  936.  
  937.                         *i_CTRL-B*
  938. CTRL-B        Toggle the 'revins' option (B for Backwards).  Only if
  939.         compiled with RIGHTLEFT (which is not the default).  See
  940.         |ins_reverse|.  {not in Vi}
  941.                         *i_CTRL-_*
  942. CTRL-_        This key is only available if Vim was compiled with RIGHTLEFT.
  943.         Its purpose is to switch between languages while in insert
  944.         mode, as follows:
  945.         -  When in a rightleft window, revins and nohkmap are toggled,
  946.            since English will likely be inserted in this case.
  947.         -  When in a norightleft window, revins and hkmap are toggled,
  948.            since Hebrew will likely be inserted in this case.
  949.  
  950.         CTRL-_ moves the cursor to the end of the typed text, unlike
  951.         CTRL-B which leaves the cursor in the same place.
  952.  
  953.         Please refer to |vim_rlh.txt| for more information about
  954.         right-to-left mode.  {not in Vi}
  955.  
  956.                         *i_<Insert>*
  957. <Insert>    Toggle between insert and replace mode.  {not in Vi}
  958. -----------------------------------------------------------------------
  959.  
  960. The effect of the <BS>, CTRL-W, and CTRL-U depend on the 'backspace' option
  961. (unless 'revins' is set):
  962.  
  963. backspace    action
  964.  option
  965.    0       delete stops in column 1 and start position of insert
  966.    1       delete stops at start position of insert
  967.    2       delete always; CTRL-W and CTRL-U stop once at start position of
  968.        insert
  969.  
  970. If the 'backspace' option is non-zero and the cursor is in column 1 when one
  971. of the three keys is used, the current line is joined with the previous
  972. line.  This effectively deletes the newline in front of the cursor.  {Vi: does
  973. not cross lines, does not delete past start position of insert}
  974.  
  975.                         *i_CTRL-V_digit*
  976. With CTRL-V followed by one, two, or three digits, you can enter the decimal
  977. value of any byte, except 10.  Normally CTRL-V is followed by three digits.
  978. The formed byte is inserted as soon as you type the third digit.  If you type
  979. only one or two digits and then a non-digit, the decimal value of those one
  980. or two digits form the byte.  After that the non-digit is dealt with in the
  981. normal way.  If you enter a value of 10, it will end up in the file as a 0.
  982. The 10 is a <NL>, which is used internally to represent the <Nul> character.
  983. When writing the buffer to a file, the <NL> character is translated into
  984. <Nul>.  The <NL> character is written at the end of each line.  Thus if you
  985. want to insert a <NL> character in a file you will have to make a line
  986. break.  The maximum value that can be entered is 255.
  987.  
  988.                         *i_CTRL-X* *insert_expand*
  989. CTRL-X enters a sub-mode where several commands can be used.  Most of these
  990. commands do keyword completion; see 4.3.6, |ins_completion|.  These are only
  991. available when Vim was compiled with INSERT_EXPAND defined.  If ":version"
  992. shows "+insert_expand" then it was; if it shows "-insert_expand" then these
  993. commands are not available.  Two commands can be used to scroll the window up
  994. or down, without exiting insert mode:
  995.  
  996.                         *i_CTRL-X_CTRL-E*
  997. CTRL-X CTRL-E        scroll window one line up.
  998.  
  999.                         *i_CTRL-X_CTRL-Y*
  1000. CTRL-X CTRL-Y        scroll window one line down.
  1001.  
  1002. After CTRL-X is pressed, each CTRL-E (CTRL-Y) scrolls the window up (down) by
  1003. one line unless that would cause the cursor to move from its current position
  1004. in the file.  As soon as another key is pressed, CTRL-X mode is exited and
  1005. that key is interpreted as in Insert mode.
  1006.  
  1007.  
  1008. 4.3.2 special special keys                *ins_special_special*
  1009.  
  1010. The following keys are special.  They stop the current insert, do something,
  1011. and then restart insertion.  This means you can do something without getting
  1012. out of Insert mode.  This is very handy if you prefer to use the Insert mode
  1013. all the time, just like editors that don't have a separate Normal mode.  You
  1014. may also want to set the 'backspace' option to 2 and set the 'insertmode'
  1015. option.  You can use CTRL-O if you want to map a function key to a command.
  1016.  
  1017. The changes (inserted or deleted characters) before and after these keys can
  1018. be undone separately.  Only the last change can be redone and always behaves
  1019. like an "i" command.
  1020.  
  1021. char        action
  1022. -----------------------------------------------------------------------
  1023. <Up>        cursor one line up                 *i_<Up>*
  1024. <Down>        cursor one line down                 *i_<Down>*
  1025. <Left>        cursor one character left             *i_<Left>*
  1026. <Right>        cursor one character right             *i_<Right>*
  1027. <S-Left>    cursor one word back (like "b" command)         *i_<S-Left>*
  1028. <S-Right>    cursor one word forward (like "w" command)   *i_<S-Right>*
  1029. <Home>        cursor to first char in the line         *i_<Home>*
  1030. <End>        cursor to after last char in the line         *i_<End>*
  1031. <C-Home>    cursor to first char in the file         *i_<C-Home>*
  1032. <C-End>        cursor to after last char in the file         *i_<C-End>*
  1033. <LeftMouse>    cursor to position of mouse click         *i_<LeftMouse>*
  1034. <S-Up>        move window one page up                 *i_<S-Up>*
  1035. <PageUp>    move window one page up                 *i_<PageUp>*
  1036. <S-Down>    move window one page down             *i_<S-Down>*
  1037. <PageDown>    move window one page down             *i_<PageDown>*
  1038. CTRL-O        execute one command and return to Insert mode*i_CTRL-O*
  1039. -----------------------------------------------------------------------
  1040.  
  1041. The CTRL-O command sometimes has one side effect: If the cursor was beyond the
  1042. end of the line, it will be put on the last character in the line.
  1043. The shifted cursor keys are not available on all terminals.
  1044.  
  1045. When the 'whichwrap' option is set appropriately, the <Left> and <Right>
  1046. keys on the first/last character in the line make the cursor wrap to the
  1047. previous/next line.
  1048.  
  1049.  
  1050. 4.3.3 'textwidth' and 'wrapmargin' options        *ins_textwidth*
  1051.  
  1052. The 'textwidth' option can be used to automatically break a line before it
  1053. gets too long.  Set the 'textwidth' option to the desired maximum line
  1054. length.  If you then type more characters (not spaces or tabs), the
  1055. last word will be put on a new line (unless it is the only word on the
  1056. line).  If you set 'textwidth' to 0, this feature is disabled.
  1057.  
  1058. The 'wrapmargin' option does almost the same.  The difference is that
  1059. 'textwidth' has a fixed width while 'wrapmargin' depends on the width of the
  1060. screen.  When using 'wrapmargin' this is equal to using 'textwidth' with a
  1061. value equal to (columns - 'wrapmargin'), where columns is the width of the
  1062. screen.
  1063.  
  1064. When 'textwidth' and 'wrapmargin' are both set, 'textwidth' is used.
  1065.  
  1066. The line is only broken automatically when using insert mode, or when
  1067. appending to a line.  When in replace mode and the line length is not
  1068. changed, the line will not be broken.
  1069.  
  1070. Long lines are broken if you enter a non-white character after the margin.
  1071. The situations where a line will be broken can be restricted by adding
  1072. characters to the 'formatoptions' option:
  1073. "l"  Only break a line if it was not longer than 'textwidth' when the insert
  1074.      started.
  1075. "v"  Only break at a white character that has been entered during the
  1076.      current insert command.  This is mostly Vi-compatible.
  1077. "lv" Only break if the line was not longer than 'textwidth' when the insert
  1078.      started and only at a white character that has been entered during the
  1079.      current insert command.  Only differs from "l" when entering non-white
  1080.      characters while crossing the 'textwidth' boundary.
  1081.  
  1082. If you want to format a block of text, you can use the "gq" operator.  Type
  1083. "gq" and a movement command to move the cursor to the end of the block.  In
  1084. many cases, the command "gq}" will do what you want (format until the end of
  1085. paragraph).  Alternatively, you can use "gqp", which will format the whole
  1086. paragraph, no matter where the cursor currently is.  Or you can use Visual
  1087. mode: hit "v", move to the end of the block, and hit "gq".  See also |gq|.
  1088.  
  1089.  
  1090. 4.3.4 'expandtab' and 'smarttab' options        *ins_expandtab*
  1091.  
  1092. If the 'expandtab' option is on, spaces will be used to fill the amount of
  1093. whitespace of the tab.  If you want to enter a real <Tab>, type CTRL-V first.
  1094. The 'expandtab' option is off by default.  Note that in Replace mode, a single
  1095. character is replaced with several spaces.  The result of this is that the
  1096. number of characters in the line increases.  Backspacing will delete one
  1097. space at a time.  The original character will be put back for only one space
  1098. that you backspace over (the last one).  {Vi does not have the 'expandtab'
  1099. option}
  1100.  
  1101.                             *ins_smarttab*
  1102. When the 'smarttab' option is on, a <Tab> inserts 'shiftwidth' positions at
  1103. the beginning of a line and 'tabstop' positions in other places.  This means
  1104. that often spaces instead of a <Tab> character are inserted.  When 'smarttab
  1105. is off, a <Tab> always inserts 'tabstop' positions, and 'shiftwidth' is only
  1106. used for ">>" and the like.  {not in Vi}
  1107.  
  1108.  
  1109. 4.3.5 Replace mode                    *replace_mode*
  1110.  
  1111. In Replace mode, one character in the line is deleted for every character you
  1112. type.  If there is no character to delete (at the end of the line), the
  1113. typed character is appended (as in Insert mode).  Thus the number of
  1114. characters in a line stays the same until you get to the end of the line.
  1115. If a <NL> is typed, a line break is inserted and no character is deleted.
  1116.  
  1117. Be careful with <Tab> characters.  If you type a normal printing character in
  1118. its place, the number of characters is still the same, but the number of
  1119. columns will become smaller.
  1120.  
  1121. If you delete characters in Replace mode (with <BS>, CTRL-W, or CTRL-U), what
  1122. happens is that you delete the changes.  The characters that were replaced
  1123. are restored.  If you had typed past the existing text, the characters you
  1124. added are deleted.  This is effectively a character-at-a-time undo.
  1125.  
  1126. If the 'expandtab' option is on, a <Tab> will replace one character with
  1127. several spaces.  The result of this is that the number of characters in the
  1128. line increases.  Backspacing will delete one space at a time.  The original
  1129. character will be put back for only one space that you backspace over (the
  1130. last one).  {Vi does not have the 'expandtab' option}
  1131.  
  1132.  
  1133. 4.3.6 Insert mode completion                *ins_completion*
  1134.  
  1135. In Insert and Replace modes, there are several commands to complete part of a
  1136. keyword or line that has been typed.  This is useful if you are using
  1137. complicated keywords (e.g., function names with capitals and underscores).
  1138. Completion can be done for:
  1139.  
  1140. 1. Whole lines                        |i_CTRL-X_CTRL-L|
  1141. 2. keywords in the current file                |i_CTRL-N|
  1142. 3. keywords in 'dictionary'                |i_CTRL-X_CTRL-K|
  1143. 4. keywords in the current and included files        |i_CTRL-X_CTRL-I|
  1144. 5. tags                            |i_CTRL-X_CTRL-]|
  1145. 6. file names                        |i_CTRL-X_CTRL-F|
  1146. 7. definitions or macros                |i_CTRL-X_CTRL-D|
  1147.  
  1148. All these (except 2) are done in CTRL-X mode.  This is a sub-mode of Insert
  1149. and Replace modes.  You enter CTRL-X mode by typing CTRL-X and one of the
  1150. CTRL-X commands.  You exit CTRL-X mode by typing a key that is not a valid
  1151. CTRL-X mode command.  Valid keys are the CTRL-X command itself, CTRL-N (next),
  1152. and CTRL-P (previous).
  1153.  
  1154. Also see the 'infercase' option if you want to adjust the case of the match.
  1155.  
  1156. Note: The keys that are valid in CTRL-X mode are not mapped.  This allows for
  1157. ":map ^F ^X^F" to work (where ^F is CTRL-F and ^X is CTRL-X).  The key that
  1158. ends CTRL-X mode (any key that is not a valid CTRL-X mode command) is mapped.
  1159.  
  1160. The following mappings are suggested to make typing the completion commands
  1161. a bit easier (although they will hide other commands):
  1162.     :inoremap ^] ^X^]
  1163.     :inoremap ^F ^X^F
  1164.     :inoremap ^D ^X^D
  1165.     :inoremap ^L ^X^L
  1166.  
  1167.  
  1168. Completing whole lines                    *compl_whole_line*
  1169.  
  1170.                             *i_CTRL-X_CTRL-L*
  1171. CTRL-X CTRL-L        Search backwards for a line that starts with the
  1172.             same characters as in the current line before the
  1173.             cursor.  Indent is ignored.  The found line is
  1174.             inserted in front of the cursor.
  1175.     CTRL-L    or
  1176.     CTRL-P        Search backwards for next matching line.  This line
  1177.             replaces the previous matching line.
  1178.  
  1179.     CTRL-N        Search forward for next matching line.  This line
  1180.             replaces the previous matching line.
  1181.  
  1182. Completing keywords in current file            *compl_current*
  1183.  
  1184.                             *i_CTRL-P*
  1185.                             *i_CTRL-N*
  1186. The keys CTRL-N and CTRL-P can be used to complete the keyword that is in
  1187. front of the cursor.  This is useful if you are writing a program that has
  1188. complicated variable names, and you want to copy a name from the text before
  1189. of after the cursor.
  1190.  
  1191. If there is a keyword in front of the cursor (a name made out of alphabetic
  1192. characters and characters in 'iskeyword'), it is used as the search pattern,
  1193. with "\<" prepended (meaning: start of a word).  Otherwise "\<\k\k" is used
  1194. as search pattern (start of any keyword of at least two characters).
  1195.  
  1196. With CTRL-N (next), the search goes forward; with CTRL-P (previous), the
  1197. search goes backward.  The first time the search starts where the cursor is.
  1198. Subsequently, the search starts at the last found position.  If you type any
  1199. other character than CTRL-P or CTRL-N, the current text is accepted and the
  1200. search pattern is forgotten.
  1201.  
  1202. If the search found a match, it is inserted at the cursor position.  Any
  1203. previous match is replaced.  If no match was found, Vim will beep.
  1204.  
  1205. In Replace mode, the number of characters that are replaced depends on the
  1206. length of the matched string.  This works like typing the characters of the
  1207. matched string in Replace mode.
  1208.  
  1209. If there is not a valid keyword character before the cursor, any keyword of
  1210. at least two characters is matched.
  1211.     e.g., to get:
  1212.         printf("(%g, %g, %g)", vector[0], vector[1], vector[2]);
  1213.     just type:
  1214.         printf("(%g, %g, %g)", vector[0], ^P[1], ^P[2]);
  1215.  
  1216. Multiple repeats of the same completion are skipped; thus a different match
  1217. will be inserted at each CTRL-N and CTRL-P (unless there is only one
  1218. matching keyword).
  1219.  
  1220. If there is only one completion found, then a second CTRL-P or CTRL-N will
  1221. give the message 'No other matches'.
  1222.  
  1223. If the only match in the file is an exact match, where no extra characters
  1224. would be typed, then the message 'Exact match only' is given (this is also
  1225. useful for checking that you typed the word correctly).
  1226.  
  1227. The mode (-- INSERT --) is shown, unless there is another more important
  1228. message (e.g., "Pattern not found").  This other message will stay until
  1229. another key is hit, and then the mode is shown again.
  1230.  
  1231. Single character matches are never included, as they usually just get in
  1232. the way of what you were really after.
  1233.     e.g., to get:
  1234.         printf("name = %s\n", name);
  1235.     just type:
  1236.         printf("name = %s\n", n^P);
  1237.     or even:
  1238.         printf("name = %s\n", ^P);
  1239. The 'n' in '\n' is skipped.
  1240.  
  1241.  
  1242. Completing keywords in 'dictionary'            *compl_dictionary*
  1243.  
  1244.                             *i_CTRL-X_CTRL-K*
  1245. CTRL-X CTRL-K        Search the files given with the 'dictionary' option
  1246.             for words that start with the keyword in front of the
  1247.             cursor.  This is like CTRL-N, but only the dictionary
  1248.             files are searched, not the current file.  The found
  1249.             keyword is inserted in front of the cursor.  This
  1250.             could potentially be pretty slow, since all matches
  1251.             are found before the first match is used.  By default,
  1252.             the 'dictionary' option is empty.
  1253.  
  1254.     CTRL-K    or
  1255.     CTRL-N        Search forward for next matching keyword.  This
  1256.             keyword replaces the previous matching keyword.
  1257.  
  1258.     CTRL-P        Search backwards for next matching keyword.  This
  1259.             keyword replaces the previous matching keyword.
  1260.  
  1261.  
  1262. Completing keywords in the current and included files    *compl_keyword*
  1263.  
  1264. The 'include' option is used to specify a line that contains an include file
  1265. name.  The 'path' option is used to search for include files.
  1266.  
  1267.                             *i_CTRL-X_CTRL-I*
  1268. CTRL-X CTRL-I        Search for the first keyword in the current and
  1269.             included files that starts with the same characters
  1270.             as those before the cursor.  The matched keyword is
  1271.             inserted in front of the cursor.
  1272.  
  1273.     CTRL-N        Search forwards for next matching keyword.  This
  1274.             keyword replaces the previous matching keyword.
  1275.             Note: CTRL-I is the same as <Tab>, which is likely to
  1276.             be typed after a succesful completion, therefore
  1277.             CTRL-I is not used for searching for the next match.
  1278.  
  1279.     CTRL-P        Search backward for previous matching keyword.  This
  1280.             keyword replaces the previous matching keyword.
  1281.  
  1282.  
  1283. Completing tags                        *compl_tag*
  1284.                             *i_CTRL-X_CTRL-]*
  1285. CTRL-X CTRL-]        Search for the first tag that starts with the same
  1286.             characters as before the cursor.  The matching tag is
  1287.             inserted in front of the cursor.  Alphabetic
  1288.             characters and characters in 'iskeyword' are used
  1289.             to decide which characters are included in the tag
  1290.             name (same as for a keyword).
  1291.     CTRL-]    or
  1292.     CTRL-N        Search forwards for next matching tag.  This tag
  1293.             replaces the previous matching tag.
  1294.  
  1295.     CTRL-P        Search backward for previous matching tag.  This tag
  1296.             replaces the previous matching tag.
  1297.  
  1298.  
  1299. Completing file names                    *compl_filename*
  1300.                             *i_CTRL-X_CTRL-F*
  1301. CTRL-X CTRL-F        Search for the first file name that starts with the
  1302.             same characters as before the cursor.  The matching
  1303.             file name is inserted in front of the cursor.
  1304.             Alphabetic characters and characters in 'isfname'
  1305.             are used to decide which characters are included in
  1306.             the file name.  Note: the 'path' option is not used
  1307.             here (yet).
  1308.     CTRL-F    or
  1309.     CTRL-N        Search forwards for next matching file name.  This
  1310.             file name replaces the previous matching file name.
  1311.  
  1312.     CTRL-P        Search backward for previous matching file name.
  1313.             This file name replaces the previous matching file
  1314.             name.
  1315.  
  1316.  
  1317. Completing definitions or macros            *compl_define*
  1318.  
  1319. The 'define' option is used to specify a line that contains a definition.
  1320. The 'include' option is used to specify a line that contains an include file
  1321. name.  The 'path' option is used to search for include files.
  1322.  
  1323.                             *i_CTRL-X_CTRL-D*
  1324. CTRL-X CTRL-D        Search in the current and included files for the
  1325.             first definition (or macro) name that starts with
  1326.             the same characters as before the cursor.  The found
  1327.             definition name is inserted in front of the cursor.
  1328.     CTRL-D    or
  1329.     CTRL-N        Search forwards for next matching macro name.  This
  1330.             macro name replaces the previous matching macro
  1331.             name.
  1332.  
  1333.     CTRL-P        Search backward for previous matching macro name.
  1334.             This macro name replaces the previous matching macro
  1335.             name.
  1336.  
  1337.  
  1338. 4.4 Command-line mode                    *mode_cmdline* *:*
  1339.  
  1340. Command-line mode is used to enter Ex commands (":"), search patterns
  1341. ("/" and "?"), and filter commands ("!").
  1342.  
  1343.  
  1344. 4.4.1 Command line editing                *cmdline_editing*
  1345.  
  1346. Normally characters are inserted in front of the cursor position.  You can
  1347. move around in the command line with the left and right cursor keys.  With the
  1348. <Insert> key, you can toggle between inserting and overstriking characters.
  1349. {Vi: can only alter the last character in the line}
  1350.  
  1351. Note that if your keyboard does not have working cursor keys or any of the
  1352. other special keys, you can use ":cnoremap" to define another key for them.
  1353. For example, to define tcsh style editing keys:        *tcsh-style*
  1354.     :cnoremap ^A <Home>
  1355.     :cnoremap ^F <Right>
  1356.     :cnoremap ^B <Left>
  1357.     :cnoremap ^[b <S-Left>
  1358.     :cnoremap ^[f <S-Right>
  1359. (All ^x characters entered with CTRL-V CTRL-x, <xx> typed literally).
  1360.  
  1361.                             *cmdline_history*
  1362. The command lines that you enter are remembered in a history table.  You can
  1363. recall them with the up and down cursor keys.  There are actually two history
  1364. tables: one for ':' commands, one for search strings.  These are completely
  1365. separate.  The search strings history can be accessed only when entering a
  1366. search string, the ':' history only when entering a command line for the ":"
  1367. command.  Use the 'history' option to set the number of lines that are
  1368. remembered (default: 20).  Note that when you enter a command line that is
  1369. excactly the same as an older one, the old one is removed (to avoid repeated
  1370. commands moving older commands out of the history).  Only commands that are
  1371. typed are remembered.  Ones that come from mappings are not put in the history
  1372. (detail: the decision is made from the last key that was typed for the line,
  1373. normally <CR>).  All searches are put in the search history, including the ones
  1374. that come from commands like "*" and "#".  {Vi: no history}
  1375.  
  1376. There is an automatic completion of names on the command line; see 4.4.2,
  1377. |cmdline_completion|.
  1378.  
  1379.                             *c_CTRL-V*
  1380. CTRL-V        Insert next non-digit literally.  Up to three digits form the
  1381.         decimal value of a single byte.  The non-digit and the three
  1382.         digits are not considered for mapping.  This works the same
  1383.         way as in Insert mode (see above, |i_CTRL-V|).
  1384.                             *c_CTRL-Q*
  1385. CTRL-Q        Same as CTRL-V.
  1386.  
  1387.                             *c_<Left>*
  1388. <Left>        cursor left
  1389.                             *c_<Right>*
  1390. <Right>        cursor right
  1391.                             *c_<S-Left>*
  1392. <S-Left>    cursor one word left
  1393.                             *c_<S-Right>*
  1394. <S-Right>    cursor one word right
  1395. CTRL-B or <Home>                    *c_CTRL-B* *c_<Home>*
  1396.         cursor to beginning of command line
  1397. CTRL-E or <End>                        *c_CTRL-E* *c_<End>*
  1398.         cursor to end of command line
  1399.  
  1400.                             *c_<LeftMouse>*
  1401. <LeftMouse>    cursor to position of mouse click.
  1402.  
  1403. CTRL-H                            *c_<BS>* *c_CTRL-H*
  1404. <BS>        delete the character in front of the cursor (see |:fixdel| if
  1405.         your <BS> key does not do what you want).
  1406.                             *c_<Del>*
  1407. <Del>        delete the character under the cursor (at end of line:
  1408.         character before the cursor) (see |:fixdel| if your <Del>
  1409.         key does not do what you want).
  1410.                             *c_CTRL-W*
  1411. CTRL-W        delete the word before the cursor
  1412.                             *c_CTRL-U*
  1413. CTRL-U        remove all characters
  1414.  
  1415.         Note: if the command line becomes empty with one of the
  1416.         delete commands, Command-line mode is quit.
  1417.                             *c_<Insert>*
  1418. <Insert>    Toggle between insert and overstrike.  {not in Vi}
  1419.  
  1420. {char1} <BS> {char2}    or                *c_digraph*
  1421. CTRL-K {char1} {char2}                    *c_CTRL-K*
  1422.         enter digraph (see 4.7, |digraphs|).  When {char1} is a special
  1423.         key, the code for that key is inserted.  {not in Vi}
  1424.  
  1425. CTRL-R <0-9a-z"%:->                    *c_CTRL-R*
  1426.         Insert the contents of a numbered or named register.  Between
  1427.         typing CTRL-R and the second character '"' will be displayed
  1428.         to indicate that you are expected to enter the name of a
  1429.         register.  The text is inserted as if you typed it, but
  1430.         mappings and abbreviations are not used.  Special registers:
  1431.             '"'    the unnamed register, containing the text of
  1432.                 the last delete or yank
  1433.             '%'    the current file name
  1434.             ':'    the last command line
  1435.             '-'    the last small (less than a line) delete
  1436.         Note: The '.' register (last inserted text) is not available
  1437.         here.  See |registers| about registers.  {not in Vi}
  1438.  
  1439. CTRL-J                        *c_CTRL-J* *c_<NL>* *c_<CR>*
  1440. <CR> or <NL>    start entered command
  1441.                             *c_<Esc>*
  1442. <Esc>        When typed and 'x' not present in 'cpoptions', quit
  1443.         Command-line mode without executing.  In macros or when 'x'
  1444.         present in 'cpoptions', start entered command.
  1445.                             *c_CTRL-C*
  1446. CTRL-C        quit command line without executing
  1447.  
  1448.                             *c_<Up>*
  1449. <Up>        recall older command line from history, whose beginning
  1450.         matches the current command line (see below).
  1451.                             *c_<Down>*
  1452. <Down>        recall more recent command line from history, whose beginning
  1453.         matches the current command line (see below).
  1454.  
  1455.                             *c_<S-Up>* *c_<PageUp>*
  1456. <S-Up> or <PageUp>
  1457.         recall older command line from history
  1458.                         *c_<S-Down>* *c_<PageDown>*
  1459. <S-Down> or <PageDown>
  1460.         recall more recent command line from history
  1461.  
  1462. CTRL-D        command line completion (see 4.4.2, |cmdline_completion|)
  1463. 'wildchar' option
  1464.         command line completion (see 4.4.2, |cmdline_completion|)
  1465. CTRL-N        command line completion (see 4.4.2, |cmdline_completion|)
  1466. CTRL-P        command line completion (see 4.4.2, |cmdline_completion|)
  1467. CTRL-A        command line completion (see 4.4.2, |cmdline_completion|)
  1468. CTRL-L        command line completion (see 4.4.2, |cmdline_completion|)
  1469.  
  1470.                             *c_CTRL-_*
  1471. CTRL-_        switch between Hebrew and English keyboard mode, which is
  1472.         private to the command line and not related to hkmap.
  1473.         This is useful when Hebrew text entry is required in the
  1474.         command line, searches, abbreviations, etc.  Applies only if
  1475.         Vim is compiled with RIGHTLEFT.  See |vim_rlh.txt|.
  1476.  
  1477. The <Up> and <Down> keys take the current command line as a search string.
  1478. The beginning of the next/previous command lines are compared with this
  1479. string.  The first line that matches is the new command line.  When typing
  1480. these two keys repeatedly, the same string is used again.  For example, this
  1481. can be used to find the previous substitute command: Type ":s" and then <Up>.
  1482. The same could be done by typing <S-Up> a number of times until the desired
  1483. command line is shown.  (Note: the shifted arrow keys do not work on all
  1484. terminals)
  1485.  
  1486.  
  1487. 4.4.2 Command line completion                *cmdline_completion*
  1488.  
  1489. When editing the command line, a few commands can be used to complete the
  1490. word before the cursor.  This is available for:
  1491.  
  1492. - Command names: at the start of the command line.  Works always.
  1493. - tags: only after the ":tag" command.
  1494. - file names: only after a command that accepts a file name or a setting for
  1495.   an option that can be set to a file name.  This is called file name
  1496.   completion.
  1497. - options: only after the ":set" command.
  1498.  
  1499. These are the commands that can be used:
  1500.  
  1501.                             *c_CTRL-D*
  1502. CTRL-D        List names that match the pattern in front of the cursor.
  1503.         When showing file names, directories are highlighted (see
  1504.         'highlight' option)
  1505.                     *c_CTRL-I* *c_wildchar* *c_<Tab>*
  1506. 'wildchar' option
  1507.         A match is done on the pattern in front of the cursor.  The
  1508.         match (if there are several, the first match) is inserted
  1509.         in place of the pattern.  (Note: does not work inside a
  1510.         macro, because <Tab> or <Esc> are mostly used as 'wildchar',
  1511.         and these have a special meaning in some macros.) When typed
  1512.         again and there were multiple matches, the next
  1513.         match is inserted.  After the last match, the first is used
  1514.         again (wrap around).
  1515.                             *c_CTRL-N*
  1516. CTRL-N        After using 'wildchar' which got multiple matches, go to next
  1517.         match.  Otherwise recall more recent command line from history.
  1518. <S-Tab>                            *c_CTRL-P* *c_<S-Tab>*
  1519. CTRL-P        After using 'wildchar' which got multiple matches, go to
  1520.         previous match.  Otherwise recall older command line from
  1521.         history.  <S-Tab> only works with the GUI, on the Amiga and
  1522.         with MS-DOS.
  1523.                             *c_CTRL-A*
  1524. CTRL-A        All names that match the pattern in front of the cursor are
  1525.         inserted.
  1526.                             *c_CTRL-L*
  1527. CTRL-L        A match is done on the pattern in front of the cursor.  If
  1528.         there is one match, it is inserted in place of the pattern.
  1529.         If there are multiple matches the longest common part is
  1530.         inserted in place of the pattern.
  1531.  
  1532. The 'wildchar' option defaults to <Tab> (CTRL-E when compiled with
  1533. COMPATIBLE; in a previous version <Esc> was used).  In the pattern standard
  1534. wildcards '*' and '?' are accepted.  '*' matches any string, '?' matches
  1535. exactly one character.
  1536.  
  1537. If you like tcsh's autolist completion, you can use this mapping:
  1538.     :cnoremap X <C-L><C-D>
  1539. (Where X is the command key to use, <C-L> is CTRL-L and <C-D> is CTRL-L)
  1540. This will find the longest match and then list all matching files.
  1541.  
  1542.                             *suffixes*
  1543. For filename completion you can use the 'suffixes' option to set a priority
  1544. between files with almost the same name.  If there are multiple matches,
  1545. those files with an extension that is in the 'suffixes' option are ignored.
  1546. The default is ".bak,~,.o,.h,.info,.swp", which means that files ending in
  1547. ".bak", "~", ".o", ".h", ".info" and ".swp" are sometimes ignored.  It is
  1548. impossible to ignore suffixes with two dots.  Examples:
  1549.  
  1550. pattern:    files:                match:
  1551. test*        test.c test.h test.o        test.c
  1552. test*        test.h test.o            test.h and test.o
  1553. test*        test.i test.h test.c        test.i and test.c
  1554.  
  1555. If there is more than one matching file (after ignoring the ones matching
  1556. the 'suffixes' option) the first file name is inserted.  You can see that
  1557. there is only one match when you type 'wildchar' twice and the completed
  1558. match stays the same.  You can get to the other matches by entering
  1559. 'wildchar', CTRL-N or CTRL-P.  All files are included, also the ones with
  1560. extensions matching the 'suffixes' option.
  1561.  
  1562. The old value of an option can be obtained by hitting 'wildchar' just after
  1563. the '='.  For example, typing 'wildchar' after ":set dir=" will insert the
  1564. current value of 'dir'.  This overrules filename completion for the options
  1565. that take a file name.
  1566.  
  1567. If you would like using <S-Tab> for CTRL-P in an xterm, put this command in
  1568. your .cshrc:
  1569.     xmodmap -e "keysym Tab = Tab Find"
  1570. And this in your .vimrc:
  1571.     cmap <Esc>[1~ <C-P>        (<C-P> is CTRL-P)
  1572.  
  1573.  
  1574. 4.4.3 Ex command lines                    *cmdline_lines*
  1575.  
  1576. The Ex commands have a few specialties:
  1577.  
  1578.                             *:quote*
  1579. '"' at the start of a line causes the whole line to be ignored.  '"'
  1580. after a command causes the rest of the line to be ignored.  This can be used
  1581. to add comments.  Example:
  1582.     :set ai        "set 'autoindent' option
  1583. It is not possible to add a comment to a shell command ":!cmd" or to the
  1584. ":map" command and friends, because they see the '"' as part of their
  1585. argument.
  1586.  
  1587.                             *:bar*
  1588. '|' can be used to separate commands, so you can give multiple commands in one
  1589. line.  The commands ":global", "vglobal", ":!", ":r !", ":w !", ":help" and
  1590. ":autocmd" see the '|' as their argument, and can therefore not be followed by
  1591. another command.  If you want '|' to be included in one of the other commands,
  1592. precede it with '\'.  Note that this is confusing (inherited from Vi).   With
  1593. ":g" the '|' is included in the command, with ":s" it is not.  There is one
  1594. execption: When the 'b' flag is present in 'cpoptions', with the ":map" and
  1595. ":abbr" commands and friends CTRL-V needs to be used instead of '\'.  See also
  1596. |map_bar|.
  1597. Examples:
  1598.     :!ls | wc        view the output of two commands
  1599.     :r !ls | wc        insert the same output in the text
  1600.     :%g/foo/p|>        moves all matching lines one shiftwidth
  1601.     :%s/foo/bar/|>        moves one line one shiftwidth
  1602.     :map q 10^V|        map "q" to "10|"
  1603.     :map q 10\| map \ l    map "q" to "10\" and map "\" to "l"
  1604.                     (when 'b' is present in 'cpoptions')
  1605.  
  1606. You can also use <NL> to separate commands in the same way as with '|'.  To
  1607. insert a <NL> use CTRL-V CTRL-J.  "^@" will be shown.  Using '|' is the
  1608. preferred method.  But for external commands a <NL> must be used, because a
  1609. '|' is included in the external command.  To avoid the special meaning of <NL>
  1610. it must be preceded with a backslash.  Example:
  1611.     :r !date<NL>-join
  1612. This reads the current date into the file and joins it with the previous line.
  1613.  
  1614. Because of vi compatibility the following strange commands are supported:
  1615.     :|            print current line (like ":p")
  1616.     :3|            print line 3 (like ":3p")
  1617.     :3            goto line 3
  1618.  
  1619. A colon is allowed between the range and the command name.  It is ignored
  1620. (this is vi compatible).  For example ":1,$:s/pat/string".
  1621.  
  1622. When the character '%' or '#' is used where a filename is expected, they are
  1623. expanded to the current and alternate filename (see the chapter "editing
  1624. files" |:_%| |:_#|).
  1625.  
  1626. Embedded spaces in filenames are allowed on the Amiga if one filename is
  1627. expected as argument.  Trailing spaces will be ignored, unless escaped with a
  1628. backslash or CTRL-V.  Note that the ":next" command uses spaces to separate
  1629. file names.  Escape the spaces to include them in a file name.  Example:
  1630.     :next foo\ bar goes\ to school\
  1631. starts editing the three files "foo bar", "goes to" and "school ".
  1632.  
  1633. When you want to use the special characters '"' or '|' in a command, or want
  1634. to use '%' or '#' in a filename, precede them with a backslash.  The backslash
  1635. is not required in a range and in the ":substitute" command.
  1636.  
  1637.                             *:_!*
  1638. The '!' (bang) character after an Ex command makes the command behave in a
  1639. different way.  The '!' should be placed immediately after the command, without
  1640. any blanks in between.  If you insert blanks the '!' will be seen as an
  1641. argument for the command, which has a different meaning.  For example:
  1642.     :w! name    write the current buffer to file "name", overwriting
  1643.             any existing file
  1644.     :w !name    send the current buffer as standard input to command
  1645.             "name"
  1646.  
  1647.  
  1648. 4.4.4 Ex command line ranges                *cmdline_ranges*
  1649.  
  1650. Some Ex commands accept a line range in front of them.  This is noted as
  1651. [range].  It consists of one or more line specifiers, separated with ',' or
  1652. ';'.  When separated with ';' the cursor position will be set to that line
  1653. before interpreting the next line specifier.  The default line specifier for
  1654. most commands is the cursor position, but the commands ":write" and
  1655. ":global" have the whole file (1,$) as default.  If more line specifiers are
  1656. given than required for the command, the first one(s) will be ignored.
  1657.  
  1658. Line numbers may be specified with:            *:range*
  1659.     {number}    an absolute line number
  1660.     .        the current line              *:.*
  1661.     $        the last line in the file          *:$*
  1662.     %        equal to 1,$ (the entire file)          *:%*
  1663.     *        equal to '<,'> (the Visual area)      *:star*
  1664.     't        position of mark t (lower case)          *:'*
  1665.     /{pattern}[/]    the next line where {pattern} matches      *:/*
  1666.     ?{pattern}[?]    the previous line where {pattern} matches *:?*
  1667.     \/        the next line where the previously used search
  1668.             pattern matches
  1669.     \?        the previous line where the previously used search
  1670.             pattern matches
  1671.     \&        the next line where the previously used substitute
  1672.             pattern matches
  1673.  
  1674. Each may be followed (several times) by '+' or '-' and an optional number.
  1675. This number is added or subtracted from the preceding line number.  If the
  1676. number is omitted, 1 is used.
  1677.  
  1678. The "/" and "?" may be preceded with another address.  The search starts from
  1679. there.  The "/" and "?" after {pattern} are required to separate the pattern
  1680. from anything that follows.
  1681.  
  1682. The {number} must be between 0 and the number of lines in the file.  A 0 is
  1683. interpreted as a 1, except with the commands tag, pop and read.
  1684.  
  1685. Examples:
  1686.     .+3        three lines below the cursor
  1687.     /that/+1    the line below the next line containing "that"
  1688.     .,$        from current line until end of file
  1689.     0;/that        the first line containing "that"
  1690.  
  1691. Some commands allow for a count after the command.  This count is used as the
  1692. number of lines to be used, starting with the line given in the last line
  1693. specifier (the default is the cursor line).  The commands that accept a count
  1694. are the ones that use a range but do not have a file name argument (because
  1695. a file name can also be a number).
  1696.  
  1697. Examples:
  1698.     :s/x/X/g 5    substitute 'x' by 'X' in the current line and four
  1699.             following lines
  1700.     :23d 4        delete lines 23, 24, 25 and 26
  1701.  
  1702. A range should have the lower line number first.  If this is not the case, Vim
  1703. will ask you if it should swap the line numbers.  This is not done within the
  1704. global command ":g".
  1705.  
  1706.                             *N:*
  1707. When giving a count before entering ":", this is translated into:
  1708.         :.,.+(count - 1)
  1709. In words: The 'count' lines at and after the cursor.  Example: To delete
  1710. three lines:
  1711.         3:d<CR>        is translated into: .,.+2d<CR>
  1712.  
  1713.                             *v_:*
  1714. {Visual}:    Starts a command line with the Visual selected lines as a
  1715.         range.  The code ":'<,'>" is used for this range, which makes
  1716.         it possible to select a similar line from the command line
  1717.         history for repeating a command on different Visually selected
  1718.         lines.
  1719.  
  1720.  
  1721. 4.4.5 Ex special characters                *cmdline_special*
  1722.  
  1723. In Ex commands, at places where a file name can be used, the following
  1724. characters have a special meaning.  To avoid the special meaning of '%' and
  1725. '#' insert a backslash before it.
  1726.     %       is replaced with the current filename        *:_%*
  1727.     #       is replaced with the alternate filename        *:_#*
  1728.     #n       (where n is a number) is replaced with the filename of
  1729.            buffer n.  "#0" is the same as "#"
  1730.  
  1731. Note: the next four are typed literally, these are not special keys!
  1732.                    *:<cword>* *:<cWORD>* *:<cfile>* *:<afile>*
  1733.     <cword>    is replaced with the word under the cursor
  1734.     <cWORD>    is replaced with the WORD under the cursor (see |WORD|)
  1735.     <cfile>    is replaced with the path name under the cursor
  1736.     <afile>    when executing autocommands, is replaced with the file name
  1737.            for a file read or write
  1738.  
  1739.                     *:_%:* *::p* *::h* *::t* *::r* *::e*
  1740. After "%", "#", "#n", "<cfile>" or "<afile>" modifiers can be given (in this
  1741. order):
  1742.     :p       Make file name a full path.  Must be the first modifier.
  1743.     :h       Head of the file name (the last component and any
  1744.            separators removed).  Cannot be used with :e, :r or :t.
  1745.            Can be repeated to remove several components at the end.
  1746.            When there is no head the result is empty.
  1747.     :t       Tail of the file name (last component of the name).  Must
  1748.            precede any :r or :e.
  1749.     :r       Root of the file name (the last extension removed).  When
  1750.            there is only an extension (file name that starts with
  1751.            '.', e.g., ".vimrc"), it is not removed.  Can be repeated to
  1752.            remove several extensions (last one first).
  1753.     :e       Extension of the file name.  Only makes sense when used
  1754.            alone.  When there is no extension the result is empty.
  1755.            When there is only an extension (file name that starts with
  1756.            '.'), the result is empty.  Can be repeated to include more
  1757.            extensions.  If there are not enough extensions (but at
  1758.            least one) as much as possible are included.
  1759.  
  1760. Examples, when the file name is "src/version.c":
  1761.     :p       /home/mool/vim/src/version.c
  1762.     :h              src
  1763.     :p:h       /home/mool/vim/src
  1764.     :p:h:h       /home/mool/vim
  1765.     :t                  version.c
  1766.     :p:t                  version.c
  1767.     :r              src/version
  1768.     :p:r       /home/mool/vim/src/version
  1769.     :t:r                  version
  1770.     :e                      c
  1771.  
  1772. Examples, when the file name is "src/version.c.gz":
  1773.     :p       /home/mool/vim/src/version.c.gz
  1774.     :e                                gz
  1775.     :e:e                                  c.gz
  1776.     :e:e:e                                c.gz
  1777.     :e:e:r                                c
  1778.     :r                        src/version.c
  1779.     :r:e                                  c
  1780.     :r:r                      src/version
  1781.     :r:r:r                    src/version
  1782.  
  1783.                                 *:_%<*
  1784. If a "<" is appended to "%", "#", "#n" or "CTRL-V p" the extension of the file
  1785. name is removed (everything after and including the last '.' in the file
  1786. name).  This is included for backwards compatibility with version 3.0, the
  1787. ":r" form is preferred.  Examples:
  1788.  
  1789.     %        current file name
  1790.     %<        current file name without extension
  1791.     #        alternate file name for current window
  1792.     #<        idem, without extension
  1793.     #31        alternate file number 31
  1794.     #31<        idem, without extension
  1795.     <cword>        word under the cursor
  1796.     <cWORD>        WORD under the cursor (see |WORD|)
  1797.     <cfile>        path name under the cursor
  1798.     <cfile><    idem, without extension
  1799.  
  1800. Note: Where a file name is expected wildcards expansion is done.  On Unix the
  1801. shell is used for this.  Backticks also work, like in ":n `echo *.c`".
  1802. But expansion is only done if there are any wildcards before expanding the
  1803. '%', '#', etc..  This avoids expanding wildcards inside a file name.
  1804. Examples: (alternate filename is "?readme?")
  1805.     command        expands to
  1806.     :e #        :e ?readme?
  1807.     :e `ls #`    :e {files matching "?readme?"}
  1808.     :e #.*        :e {files matching "?readme?.*"}
  1809.  
  1810.  
  1811. 4.5 The window contents                    *window_contents*
  1812.  
  1813. In command and Insert/Replace mode the screen window will show the current
  1814. contents of the buffer: What You See Is What You Get.  There are two
  1815. exceptions:
  1816. - When the 'cpoptions' option contains '$', and the change is within one line,
  1817.   the text is not directly deleted, but a '$' is put at the last deleted
  1818.   character.
  1819. - When inserting text in one window, other windows on the same text are not
  1820.   updated until the insert is finished.
  1821. {Vi: The screen is not always updated on slow terminals}
  1822.  
  1823. Lines longer than the window width will wrap, unless the 'wrap' option is off
  1824. (see below).  The 'linebreak' option can be set to wrap at a blank character.
  1825.  
  1826. The bottom lines in the window may start with one of these two characters:
  1827.  
  1828. '@'    The next line is too long to fit in the window.
  1829. '~'    Below the last line in the buffer.
  1830.  
  1831. If the bottom line is completely filled with '@', the line that is at the
  1832. top of the window is too long to fit in the window.  If the cursor is on this
  1833. line you can't see what you are doing, because this part of the line is not
  1834. shown.  However, the part of the line before the '@'s can be edited normally.
  1835. {Vi: gives an "internal error" on lines that do not fit in the window}
  1836.  
  1837. The 'showbreak' option contains the string to put in front of wrapped lines.
  1838.  
  1839.                             *wrap_off*
  1840. If the 'wrap' option is off, long lines will not wrap.  Only the part that
  1841. fits on the screen is shown.  If the cursor is moved to a part of the line
  1842. that is not shown, the screen is scrolled horizontally.  The advantage of
  1843. this method is that columns are shown as they are and lines that cannot fit
  1844. on the screen can be edited.  The disadvantage is that you cannot see all the
  1845. characters of a line at once.  The 'sidescroll' option can be set to the
  1846. minimal number of columns to scroll.  {Vi: has no 'wrap' option}
  1847.  
  1848. All normal ASCII characters are displayed directly on the screen.  The <Tab>
  1849. is replaced with the number of spaces that it represents.  Other non-printing
  1850. characters are replaced with "^{char}", where {char} is the non-printing
  1851. character with 64 added.  Thus character 7 (bell) will be shown as "^G".
  1852. Characters between 127 and 160 are replaced with "~{char}", where {char} is
  1853. the character with 64 subtracted.  These characters occupy more than one
  1854. position on the screen.  The cursor can only be positioned on the first one.
  1855.  
  1856. If you set the 'number' option, all lines will be preceded with their
  1857. number.  Tip: If you don't like wrapping lines to mix with the line numbers,
  1858. set the 'showbreak' option to eight spaces:
  1859.     ":set showbreak=\ \ \ \ \ \ \ \ "
  1860.  
  1861. If you set the 'list' option, <Tab> characters will not be shown as several
  1862. spaces, but as "^I".  A '$' will be placed at the end of the line, so you can
  1863. find trailing blanks.
  1864.  
  1865. In Command-line mode only the command line itself is shown correctly.  The
  1866. display of the buffer contents is updated as soon as you go back to Command
  1867. mode.
  1868.  
  1869. Some commands hand over the window to external commands (e.g., ":shell" and
  1870. "=").  After these commands are finished the window may be clobbered with
  1871. output from the external command, so it needs to be redrawn.  This is also
  1872. the case if something is displayed on the status line that is longer than
  1873. the width of the window.  If you are expected to have a look at the screen
  1874. before it is redrawn, you get this message:
  1875.  
  1876.     Press RETURN or enter command to continue
  1877.  
  1878. After you type a key the screen will be redrawn and Vim continues.  If you
  1879. type <CR>, <SP> or <NL> nothing else happens.  If you type any other key, it
  1880. will be interpreted as (the start of) a new command.  {Vi: only ":" commands
  1881. are interpreted}
  1882.  
  1883. The last line of the window is used for status and other messages.  The
  1884. status messages will only be used if an option is on:
  1885.  
  1886. status message            option         default    Unix default
  1887. current mode            'showmode'    on        on
  1888. command characters        'showcmd'    on        off
  1889. cursor position            'ruler'        off        off
  1890.  
  1891. The current mode is "-- INSERT --" or "-- REPLACE --", see |'showmode'|.  The
  1892. command characters are those that you typed but were not used yet.  {Vi: does
  1893. not show the characters you typed or the cursor position}
  1894.  
  1895. If you have a slow terminal you can switch off the status messages to speed
  1896. up editing:
  1897.     :set nosc noru nosm
  1898.  
  1899. If there is an error, an error message will be shown for at least one second
  1900. (in reverse video).  {Vi: error messages may be overwritten with other
  1901. messages before you have a chance to read them}
  1902.  
  1903. Some commands show how many lines were affected.  Above which threshold this
  1904. happens can be controlled with the 'report' option (default 2).
  1905.  
  1906. On the Amiga Vim will run in a CLI window.  The name Vim and the full name of
  1907. the current filename will be shown in the title bar.  When the window is
  1908. resized, Vim will automatically redraw the window.  You may make the window as
  1909. small as you like, but if it gets too small not a single line will fit in it.
  1910. Make it at least 40 characters wide to be able to read most messages on the
  1911. last line.
  1912.  
  1913. On most Unix systems window resize works ok.  {Vi: not ok}
  1914.  
  1915.  
  1916. 4.6 Abbreviations                    *abbreviations*
  1917.  
  1918. Abbreviations are used in insert mode, Replace mode and Command-line mode.
  1919. If you enter a word that is an abbreviation, it is replaced with the word it
  1920. stands for.  This can be used to save typing for often used long words.
  1921.  
  1922. There are three types of abbreviations:
  1923.  
  1924. full-id      The "full-id" type consists entirely of keyword characters (letters
  1925.       and characters from 'iskeyword' option).  This is the most common
  1926.       abbreviation.
  1927.  
  1928.       Examples: "foo", "g3", "-1"
  1929.  
  1930. end-id      The "end-id" type ends in a keyword character, but all the other
  1931.       characters are not keyword characters.
  1932.  
  1933.       Examples: "#i", "..f", "$/7"
  1934.  
  1935. non-id      The "non-id" type ends in a non-keyword character, the other
  1936.       characters may be of any type, excluding space and Tab.  {this type
  1937.       is not supported by Vi}
  1938.  
  1939.       Examples: "def#", "4/7$"
  1940.  
  1941. Examples of strings that cannot be abbreviations: "a.b", "#def", "a b", "_$r"
  1942.  
  1943. An abbreviation is only recognized when you type a non-keyword character.
  1944. This can also be the <Esc> that ends insert mode or the <CR> that ends a
  1945. command.  The characters before the cursor must match the abbreviation.  Each
  1946. type has an additional rule:
  1947.  
  1948. full-id      In front of the match is a non-keyword character, or this is where
  1949.       the line or insertion starts.  Exception: When the abbreviation is
  1950.       only one character, it is not recognized if there is a non-keyword
  1951.       character in front of it, other than a space or a <Tab>.
  1952.  
  1953. end-id      In front of the match is a keyword character, or a space or a <Tab>,
  1954.       or this is where the line or insertion starts.
  1955.  
  1956. non-id      In front of the match is a space, <Tab> or the start of the line or
  1957.       the insertion.
  1958.  
  1959. Examples: (<CURSOR> is where you type a non-keyword character)
  1960.     ":ab foo four old otters" (Note that spaces in the <rhs> are allowed
  1961.                   and included in the replacement string.)
  1962.         " foo<CURSOR>"      is expanded to " four old otters"
  1963.         " foobar<CURSOR>" is not expanded
  1964.         "barfoo<CURSOR>"  is not expanded
  1965.  
  1966.     ":ab #i #include"
  1967.         "#i<CURSOR>"      is expanded to "#include"
  1968.         ">#i<CURSOR>"      is not expanded
  1969.  
  1970.     ":ab ;; <endofline>"
  1971.         "test;;"      is not expanded
  1972.         "test ;;"      is expanded to "test <endofline>"
  1973.  
  1974. To avoid the abbreviation in insert mode: Type part of the abbreviation, exit
  1975. insert mode with <Esc>, re-enter insert mode with "a" and type the rest.  Or
  1976. type CTRL-V before the character after the abbreviation.
  1977. To avoid the abbreviation in Command-line mode: Type CTRL-V twice somewhere in
  1978. the abbreviation to avoid it to be replaced.  A CTRL-V in front of a normal
  1979. character is mostly ignored otherwise.
  1980.  
  1981. There are no default abbreviations.
  1982.  
  1983. Abbreviations are never recursive.  You can use ":ab f f-o-o" without any
  1984. problem.  But abbreviations can be mapped.  {some versions of Vi support
  1985. recursive abbreviations, for no apparent reason}
  1986.  
  1987. Abbreviations are disabled if the 'paste' option is on.
  1988.  
  1989.                         *:ab* *:abbreviate*
  1990. :ab[breviate]        list all abbreviations.  The character in the first
  1991.             column indicates the mode where the abbreviation is
  1992.             used: 'i' for insert mode, 'c' for Command-line
  1993.             mode, '!' for both.
  1994.  
  1995. :ab[breviate] <lhs>    list the abbreviations that start with <lhs>
  1996.  
  1997. :ab[breviate] <lhs> <rhs>
  1998.             add abbreviation for <lhs> to <rhs>.  If <lhs> already
  1999.             existed it is replaced with the new <rhs>.  <rhs> may
  2000.             contain spaces.
  2001.  
  2002.                         *:una* *:unabbreviate*
  2003. :una[bbreviate] <lhs>    remove abbreviation for <lhs> from the list
  2004.  
  2005.                         *:norea* *:noreabbrev*
  2006. :norea[bbrev] [lhs] [rhs]
  2007.             same as ":ab", but no remapping for this <rhs> {not
  2008.             in Vi}
  2009.  
  2010.                         *:ca* *:cabbrev*
  2011. :ca[bbrev] [lhs] [rhs]    same as ":ab", but for Command-line mode only.  {not
  2012.             in Vi}
  2013.  
  2014.                         *:cuna* *:cunabbrev*
  2015. :cuna[bbrev] <lhs>    same as ":una", but for Command-line mode only.  {not
  2016.             in Vi}
  2017.  
  2018.                         *:cnorea* *:cnoreabbrev*
  2019. :cnorea[bbrev] [lhs] [rhs]
  2020.             same as ":ab", but for Command-line mode only and no
  2021.             remapping for this <rhs> {not in Vi}
  2022.  
  2023.                         *:ia* *:iabbrev*
  2024. :ia[bbrev] [lhs] [rhs]    same as ":ab", but for Insert mode only.  {not in Vi}
  2025.  
  2026.                         *:iuna* *:iunabbrev*
  2027. :iuna[bbrev] <lhs>    same as ":una", but for insert mode only.  {not in
  2028.             Vi}
  2029.  
  2030.                         *:inorea* *:inoreabbrev*
  2031. :inorea[bbrev] [lhs] [rhs]
  2032.             same as ":ab", but for Insert mode only and no
  2033.             remapping for this <rhs> {not in Vi}
  2034.  
  2035.                             *:abc* *:abclear*
  2036. :abc[lear]        Remove all abbreviations.  {not in Vi}
  2037.  
  2038.                             *:iabc* *:iabclear*
  2039. :iabc[lear]        Remove all abbreviations for Insert mode.  {not in Vi}
  2040.  
  2041.                             *:cabc* *:cabclear*
  2042. :cabc[lear]        Remove all abbreviations for Command-line mode.  {not
  2043.             in Vi}
  2044.  
  2045.  
  2046.  
  2047. 4.7 Digraphs                        *digraphs*
  2048.  
  2049.                         *:dig* *:digraphs*
  2050. :dig[raphs]        show currently defined digraphs.  {not in Vi}
  2051.  
  2052. :dig[raphs] {char1}{char2} {number} ...
  2053.             Add digraph {char1}{char2} to the list.  {number} is
  2054.             the decimal representation of the character.
  2055.  
  2056. Digraphs are used to enter characters that normally cannot be entered by
  2057. an ordinary keyboard.  These are mostly accented characters which have the
  2058. eighth bit set.  The digraphs are easier to remember than the decimal number
  2059. that can be entered with CTRL-V (see above).
  2060.  
  2061. Vim must have been compiled with DIGRAPHS defined.  If this wasn't done, the
  2062. ":digraph" command will display an error message.  You can also check this
  2063. with the ":version" command.  If it shows "+digraphs" then it's included,
  2064. "-digraphs" means it's not included.
  2065.  
  2066. There are two methods to enter digraphs:            *i_digraph*
  2067.     CTRL-K {char1} {char2}        or
  2068.     {char1} <BS> {char2}
  2069. The first is always available.  The second only when the 'digraph' option is
  2070. set.
  2071.  
  2072. If a digraph with {char1}{char2} does not exist, a digraph {char2}{char1} is
  2073. searched for.  This will help when you don't remember which character comes
  2074. first.
  2075.  
  2076. Note that when you enter CTRL-K {char1}, where {char1} is a special key, the
  2077. code for that special key is entered.  This is not a digraph.
  2078.  
  2079. Once you have entered the digraph the character is treated like a normal
  2080. character, taking up only one character in the file and on the screen.
  2081. Example:
  2082.     '|' <BS> '|'    will enter the double '|' character (166)
  2083.     'a' <BS> '^'    will enter an 'a' with a hat (226)
  2084.     CTRL-K '-' '-'    will enter a minus sign (173)
  2085.  
  2086. The default digraphs are listed in the file "vim_digr.txt" |digraph_table|.
  2087. There are two sets: One that is used for MS-DOS and one for the international
  2088. standard character set that is mostly used on Unix systems and the Amiga.
  2089. With the wrong character set they will look illogical.
  2090.  
  2091. For CTRL-K there is one general digraph: CTRL-K <Space> {char} will enter
  2092. {char} with the highest bit set.  This can be used to enter meta-characters.
  2093.  
  2094. The <Esc> character cannot be part of a digraph.  When hitting <Esc> the
  2095. entering of the digraph is aborted and Insert mode or command-line mode is
  2096. ended, just like hitting an <Esc>.
  2097.  
  2098. If you accidently typed an 'a' that should be an 'e', you will type 'a' <BS>
  2099. 'e'.  But that is a digraph, so you will not get what you want.  To correct
  2100. this, you will have to type <BS> e again.  To avoid this don't set the
  2101. 'digraph' option and use CTRL-K to enter digraphs.
  2102.  
  2103. You may have problems using Vim with characters which have an ascii value >
  2104. 128.  For example: You insert ue (u-umlaut) and the editor echoes \334 in
  2105. Insert mode.  After leaving the Insert mode everything is fine.  Also fmt
  2106. removes all characters with ascii > 128 from the text being formated.
  2107. On some Unix systems this means you have to define the environment-variable
  2108. LC_CTYPE.  If you are using csh then put in your .cshrc following line:
  2109.     setenv LC_CTYPE=iso_8859_1
  2110.  
  2111.  
  2112. 4.8 Using the mouse                    *mouse_using*
  2113.  
  2114. This section is about using the mouse on a terminal or a terminal window.  How
  2115. to use the mouse in a GUI window is explained in |gui_mouse|.  Don't forget to
  2116. do ":set mouse=a", otherwise Vim won't recognize the mouse in all modes (See
  2117. 'mouse').
  2118.  
  2119. Currently the mouse is supported for Unix in an xterm window and for MS-DOS.
  2120. Mouse clicks can be used to position the cursor, select the Visual area and
  2121. paste.  There are no menus, use the GUI version for that.
  2122.  
  2123. The characters in the 'mouse' option tell in which situations the mouse will
  2124. be used by Vim:
  2125.         n    Normal mode
  2126.         v    Visual mode
  2127.         i    Insert mode
  2128.         c    Command-line mode
  2129.         h    all previous modes when in a help file
  2130.         a    all previous modes
  2131.         r    for "Hit return ..." question
  2132.  
  2133. The default for 'mouse' is empty, the mouse is not used.  Normally you would do
  2134.     :set mouse=a
  2135. to start using the mouse (this is equivalent to setting 'mouse' to "nvich").
  2136. If you only want to use the mouse in a few modes or also want to use it for
  2137. the two questions you will have to concatenate the letters for those modes.
  2138. For example:
  2139.     :set mouse=nv
  2140. Will make the mouse work in Normal mode and Visual mode.
  2141.     :set mouse=h
  2142. Will make the mouse work in help files only (so you can use "g<LeftMouse>" to
  2143. jump to tags).
  2144.  
  2145. In an xterm, with the currently active mode included in the 'mouse' option,
  2146. normal mouse clicks are used by Vim, mouse clicks with the shift or ctrl key
  2147. pressed go the the xterm.  With the currently active mode not included in
  2148. 'mouse' all mouse clicks go to the xterm.
  2149.  
  2150. Here is how you copy and paste a piece of text:
  2151.  
  2152. Copy/paste with the mouse and Visual mode ('mouse' option must be set, see
  2153. above):
  2154. 1. Press left mouse button on first letter of text, move mouse pointer to last
  2155.    letter of the text and release the button.  This will start Visual mode and
  2156.    highlight the selected area.
  2157. 2. Press "y" to yank the Visual text in the unnamed register.
  2158. 3. Click the left mouse button at the insert position.
  2159. 4. Click the middle mouse button.
  2160.  
  2161. Shortcut: If the insert position is on the screen at the same time as the
  2162. Visual text, you can do 2, 3 and 4 all in one: Click the middle mouse button
  2163. at the insert position.
  2164.  
  2165.                             *xterm_copy_paste*
  2166. Copy/paste in xterm with (current mode NOT included in 'mouse'):
  2167. 1. Press left mouse button on first letter of text, move mouse pointer to last
  2168.    letter of the text and release the button.
  2169. 2. Use normal Vim commands to put the cursor at the insert position.
  2170. 3. Press "a" to start Insert mode.
  2171. 4. Click the middle mouse button.
  2172. 5. Press ESC to end Insert mode.
  2173. (The same can be done with anything in 'mouse' if you keep the shift key
  2174. pressed while using the mouse)
  2175.  
  2176. Note: if you loose the 8th bit when pasting (special characters are translated
  2177. into other characters), you may have to do "stty cs8 -istrip" in your shell
  2178. before starting Vim.
  2179.  
  2180. Thus in an xterm the shift and ctrl keys cannot be used with the mouse.  To
  2181. make it possible to do the mouse commands that require the ctrl modifier, the
  2182. "g" key can be typed before using the mouse:
  2183.     "g<LeftMouse>"    is "<C-LeftMouse>    (jump to tag under mouse click)
  2184.     "g<RightMouse>" is "<C-RightMouse>    ("CTRL-T")
  2185.  
  2186. A short overview of what the mouse buttons do:
  2187.  
  2188. Normal Mode:
  2189. event          position       Visual      change  action
  2190.            cursor              window
  2191. <LeftMouse>     yes         end        yes
  2192. <C-LeftMouse>   yes         end        yes       "CTRL-]" (2)
  2193. <S-LeftMouse>   yes      no change        yes       "*" (2)    *<S-LeftMouse>*
  2194. <LeftDrag>      yes    start or extend (1) no              *<LeftDrag>*
  2195. <LeftRelease>   yes    start or extend (1) no
  2196. <MiddleMouse>   yes      if not active     no       put
  2197. <MiddleMouse>   yes      if active        no       yank and put
  2198. <RightMouse>    yes    start or extend     yes
  2199. <S-RightMouse>  yes       no change        yes       "#" (2)    *<S-RightMouse>*
  2200. <C-RightMouse>  no            no change        no       "CTRL-T"
  2201. <RightDrag>     yes        extend        no              *<RightDrag>*
  2202. <RightRelease>  yes        extend        no              *<RightRelease>*
  2203.  
  2204. Insert or Replace Mode:
  2205. event          position       Visual      change  action
  2206.            cursor              window
  2207. <LeftMouse>     yes     (cannot be active)  yes
  2208. <C-LeftMouse>   yes     (cannot be active)  yes       "CTRL-O^]" (2)
  2209. <S-LeftMouse>   yes     (cannot be active)  yes       "CTRL-O*" (2)
  2210. <LeftDrag>      yes     start or extend (1) no       like CTRL-O (1)
  2211. <LeftRelease>   yes     start or extend (1) no       like CTRL-O (1)
  2212. <MiddleMouse>   no      (cannot be active)  no       put register
  2213. <RightMouse>    yes     start or extend        yes       like CTRL-O
  2214. <S-RightMouse>  yes     (cannot be active)  yes       "CTRL-O#" (2)
  2215. <C-RightMouse>  no         (cannot be active)  no       "CTRL-O CTRL-T"
  2216.  
  2217. (1) only if mouse pointer moved since press
  2218. (2) only if click is in same buffer
  2219.  
  2220. Clicking the left mouse button causes the cursor to be positioned.  If the
  2221. click is in another window that window is made the active window.  When
  2222. editing the command line the cursor can only be positioned on the
  2223. command line.  When in Insert mode Vim remains in Insert mode.  If 'scrolloff'
  2224. is set, and the cursor is positioned within 'scrolloff' lines from the window
  2225. border, the text is scrolled.
  2226.  
  2227. A Visual area can be selected by pressing the left mouse button on the first
  2228. character, moving the mouse to the last character, then releasing the mouse
  2229. button.  You will not always see the Visual selection until you release the
  2230. button, only in some versions (GUI, MS-DOS, WIN32) will the dragging be shown
  2231. immediately.  Note that you can make the text scroll by moving the mouse at
  2232. least one character in the first/last line in the window when 'scrolloff' is
  2233. non-zero.
  2234.  
  2235. In Normal and Visual mode clicking the right mouse button causes the Visual
  2236. area to be extended.  When clicking in a window which is editing another
  2237. buffer, the Visual mode is stopped.
  2238.  
  2239. Double, triple and quadruple clicks are supported when the GUI is active,
  2240. for MS-DOS and Win32, and for an xterm (if the gettimeofday() function is
  2241. available).  Double clicking may be done to make the selection word-wise,
  2242. triple clicking makes it line-wise, and quadruple clicking makes it
  2243. rectangular block-wise.  For MS-DOS and xterm the time for double clicking can
  2244. be set with the 'mousetime' option.  For the other systems this time is
  2245. defined outside of Vim.
  2246.  
  2247. In Insert mode, when a Visual area is selected, Vim goes into Normal mode
  2248. temporarily.  When Visual mode ends, it returns to Insert mode.  This is like
  2249. using CTRL-O in Insert mode.
  2250.  
  2251.                             *drag_status_line*
  2252. When working with several windows, the size of the windows can be changed by
  2253. dragging the status line with the mouse.  Point the mouse at a status line,
  2254. press the left button, move the mouse to the new position of the status line,
  2255. release the button.  Just clicking the mouse in a status line makes that window
  2256. the current window, without moving the cursor.  If by selecting a window it
  2257. will change position or size, the dragging of the status line will look
  2258. confusing, but it will work (just try it).
  2259.  
  2260. Mouse clicks can be mapped.  The codes for mouse clicks are:
  2261.      code        mouse button          normal action
  2262.  <LeftMouse>     left pressed            set cursor position
  2263.  <LeftDrag>     left moved while pressed   extend Visual area
  2264.  <LeftRelease>     left released            set Visual area end
  2265.  <MiddleMouse>     middle pressed            paste text at cursor position
  2266.  <MiddleDrag>     middle moved while pressed -
  2267.  <MiddleRelease> middle released        -
  2268.  <RightMouse>     right pressed            extend Visual area
  2269.  <RightDrag>     right moved while pressed  extend Visual area
  2270.  <RightRelease>  right released            set Visual area end
  2271.  
  2272. Examples:
  2273.     :noremap <MiddleMouse> <LeftMouse><MiddleMouse>
  2274. Paste at the position of the middle mouse button click (otherwise the paste
  2275. would be done at the cursor position).
  2276.  
  2277.     :noremap <LeftRelease> <LeftRelease>y
  2278. Immediately yank the Visually highlighted text.
  2279.  
  2280. Note the use of ":noremap" instead of "map" to avoid a recursive mapping.
  2281.  
  2282.                         *mouse_swap_buttons*
  2283. To swap the meaning of the left and right mouse buttons:
  2284.     :noremap    <LeftMouse>    <RightMouse>
  2285.     :noremap    <LeftDrag>    <RightDrag>
  2286.     :noremap    <LeftRelease>    <RightRelease>
  2287.     :noremap    <RightMouse>    <LeftMouse>
  2288.     :noremap    <RightDrag>    <LeftDrag>
  2289.     :noremap    <RightRelease>    <LeftRelease>
  2290.     :noremap    g<LeftMouse>    <C-RightMouse>
  2291.     :noremap    g<RightMouse>    <C-LeftMouse>
  2292.     :noremap!    <LeftMouse>    <RightMouse>
  2293.     :noremap!    <LeftDrag>    <RightDrag>
  2294.     :noremap!    <LeftRelease>    <RightRelease>
  2295.     :noremap!    <RightMouse>    <LeftMouse>
  2296.     :noremap!    <RightDrag>    <LeftDrag>
  2297.     :noremap!    <RightRelease>    <LeftRelease>
  2298.  
  2299.  
  2300. 4.9 Online help                    *online_help*
  2301.  
  2302.             *help* *<Help>* *:h* *:help* *<F1>* *i_<F1>* *i_<Help>*
  2303. <Help>        or
  2304. :h[elp]            Split the window and display the help file in
  2305.             read-only mode.  If there is a help window open
  2306.             already, use that one.  {not in Vi}
  2307.  
  2308. :h[elp] {subject}    Like ":help", additionally jump to the tag
  2309.             {subject}.  {subject} can be a regular expression.
  2310.                :help z.    jump to help for any "z" command
  2311.                :help z\.    jump to the help for "z."
  2312.             If there is no full match for the pattern, or there
  2313.             are several matches, the "best" match will be used.
  2314.             A match is considered to be better when:
  2315.             - if no match with same case is found, a match with
  2316.               ignoring case will be used
  2317.             - the match is after a non-alphanumereic character
  2318.             - it is at near the beginning of the tag
  2319.             - more alphanumeric characters match
  2320.             - the length of the matched is smaller
  2321.             Note that the longer the {subject} you give, the less
  2322.             matches will be found.  You can get an idea how this
  2323.             all works by using commandline completion (type CTRL-D
  2324.             after ":help subject".  {not in Vi}
  2325.  
  2326. The help file name can be set with the 'helpfile' option.  The initial height
  2327. of the help window can be set with the 'helpheight' option (default 20).
  2328. Jump to specific subjects by using tags.  This can be done in two ways:
  2329. - Use the "CTRL-]" command while standing on the name of a command or option.
  2330.   This only works when the tag is a keyword.  "<C-Leftmouse>" and
  2331.   "g<LeftMouse>" work just like "CTRL-]".
  2332. - use the ":ta {subject}" command.  This works with all characters.
  2333.  
  2334. Use "CTRL-T" to jump back.
  2335. Use ":q" to close the help window.
  2336.  
  2337.                             *help_xterm_window*
  2338. If you want to have the help in another xterm window, you could use this
  2339. command:
  2340.     :!xterm -e vim +help &
  2341.  
  2342.                             *doc_files*
  2343. All the help files must be in the same directory.  The files are:
  2344.     vim_help.txt    overview and quick reference          |vim_help.txt|
  2345.     vim_idx.txt    alphabetical index of all commands    |vim_idx.txt|
  2346.     vim_ref.txt    reference manual (this file)          |vim_ref.txt|
  2347.     vim_win.txt    reference manual for windows commands |vim_win.txt|
  2348.     vim_diff.txt    main differences between Vim and Vi   |vim_diff.txt|
  2349.     vim_digr.txt    list of available digraphs          |vim_digr.txt|
  2350.     vim_tips.txt    tips on using Vim              |vim_tips.txt|
  2351.     vim_gui.txt    about the Graphical User Interface    |vim_gui.txt|
  2352.     vim_40.txt    about version 4.0              |vim_40.txt|
  2353.     vim_rlh.txt    about the 'rightleft' option          |vim_rlh.txt|
  2354.  
  2355.     vim_unix.txt    Unix specific remarks              |vim_unix.txt|
  2356.     vim_ami.txt    Amiga specific remarks              |vim_ami.txt|
  2357.     vim_dos.txt    MS-DOS specific remarks              |vim_dos.txt|
  2358.     vim_w32.txt    Windows-NT/95 specific remarks          |vim_w32.txt|
  2359.     vim_os2.txt    OS/2 specific remarks              |vim_os2.txt|
  2360.     vim_arch.txt    Archimedes specific remarks          |vim_arch.txt|
  2361.     vim_mac.txt    Macintosh specific remarks          |vim_mac.txt|
  2362.     vim_mint.txt    Atari MiNT specific remarks           |vim_mint.txt|
  2363.  
  2364.     vim_tags    tags file for documentation
  2365.  
  2366.  
  2367. 5. Editing files                    *edit_files*
  2368. ================
  2369.  
  2370. 5.1 Introduction                    *edit_intro*
  2371.  
  2372. Editing a file with Vim means:
  2373.  
  2374. 1. reading the file into the internal buffer
  2375. 2. changing the buffer with editor commands
  2376. 3. writing the buffer into a file
  2377.  
  2378. As long as you don't write the buffer, the original file remains unchanged.
  2379. If you start editing a file (read a file into the buffer), the file name is
  2380. remembered as the "current filename".
  2381.  
  2382. If there already was a current filename, then that one becomes the alternate
  2383. file name.  All filenames are remembered in the file list.  When you enter a
  2384. filename, for editing (e.g., with ":e filename") or writing (e.g., with (:w
  2385. filename"), the filename is added to the list.  You can use this list to
  2386. remember which files you edited and to quickly switch from one file to
  2387. another with the CTRL-^ command (e.g., to copy text).  First type the number
  2388. of the file and then hit CTRL-^.  {Vi: only one alternate filename}
  2389.  
  2390. CTRL-G        or                *CTRL-G* *:f* *:file*
  2391. :f[ile]            Prints the current filename (as typed), the
  2392.             cursor position (unless the 'ruler' option is set),
  2393.             and the file status (readonly, modified).  See the
  2394.             'shortmess' option about how tho make this message
  2395.             shorter.  {Vi does not include column number}
  2396.  
  2397. {count}CTRL-G        Like CTRL-G, but prints the current filename with full
  2398.             path.  If the count is higher than 1 the current
  2399.             buffer number is also given.  {not in Vi}
  2400.  
  2401.                             *g_CTRL-G*
  2402. g CTRL-G        Prints the current position of the cursor in three
  2403.             ways: Column, Line and Character.  If there are
  2404.             characters in the line that take more than one
  2405.             position on the screen (<Tab> or special character),
  2406.             both the "real" column and the screen column are
  2407.             shown, separated with a dash.  See also 'ruler'
  2408.             option.  {not in Vi}
  2409.  
  2410.                             *:file_f*
  2411. :f[ile] {name}        Sets the current filename to {name}.
  2412.  
  2413. :buffers
  2414. :files
  2415. :ls            List all the currently known file names.  See
  2416.             'vim_win.txt' |:files| |:buffers| |:ls|.  {not in
  2417.             Vi}
  2418.  
  2419. Vim will remember the full path name of a file name that you enter.  In most
  2420. cases when the file name is displayed only the name you typed is shown, but
  2421. the full path name is being used if you used the ":cd" command |:cd|.
  2422.  
  2423.                             *home_replace*
  2424. If the environment variable 'HOME' is set, and the file name starts with that
  2425. string, it is often displayed with HOME replaced with "~".  This was done to
  2426. keep file names short.  When reading or writing files the full name is still
  2427. used, the "~" is only used when displaying file names.  When replacing the
  2428. file name would result in just "~", "~/" is used instead (to avoid confusion
  2429. with 'backupext' set to "~").
  2430.  
  2431. When writing the buffer, the default is to use the current filename.  Thus
  2432. when you give the "ZZ" or ":wq" command, the original file will be
  2433. overwritten.  If you do not want this, the buffer can be written into another
  2434. file by giving a filename argument to the ":write" command.  For example:
  2435.  
  2436.     vim testfile
  2437.     [change the buffer with editor commands]
  2438.     :w newfile
  2439.     :q
  2440.  
  2441. This will create a file "newfile", that is a modified copy of "testfile".
  2442. The file "testfile" will remain unchanged.  Anyway, if the 'backup' option is
  2443. set, Vim renames or copies the original file before it will be overwritten.
  2444. You can use this file if you discover that you need the original file.  See
  2445. also the 'patchmode' option.  The name of the backup file is normally the same
  2446. as the original file with 'backupext' appended.  The default "~" is a bit
  2447. strange to avoid accidently overwriting existing files.  If you prefer ".bak"
  2448. change the 'backupext' option.  Extra dots are replaced with '_' on MS-DOS
  2449. machines, when Vim has detected that an MS-DOS-like filesystem is being used
  2450. (e.g., messydos or crossdos) or when the 'shortname' option is on.  The
  2451. backup file can be placed in another directory by setting 'backupdir'.
  2452.  
  2453.                             *auto_shortname*
  2454. Technical: On the Amiga you can use 30 characters for a file name.  But on an
  2455.        MS-DOS-compatible filesystem only 8 plus 3 characters are
  2456.        available.  Vim tries to detect the type of filesystem when it is
  2457.        creating the .swp file.  If an MS-DOS-like filesystem is suspected,
  2458.        a flag is set that has the same effect as setting the 'shortname'
  2459.        option.  This flag will be reset as soon as you start editing a
  2460.        new file.  The flag will be used when making the filename for the
  2461.        ".swp" and ".~" files for the current file.  But when you are
  2462.        editing a file in a normal filesystem and write to an MS-DOS-like
  2463.        filesystem the flag will not have been set.  In that case the
  2464.        creation of the ".~" file may fail and you will get an error
  2465.        message.  Use the 'shortname' option in this case.
  2466.  
  2467. When you started editing without giving a file name, "No File" is displayed in
  2468. messages.  If the ":write" command is used with a file name argument, the file
  2469. name for the current file is set to that file name.  This only happens when
  2470. the 'F' flag is included in 'cpoptions' (by default it is included).  This is
  2471. useful when entering text in an empty buffer and then writing it to a file.
  2472. If 'cpoptions' contains the 'f' flag (by default it is NOT included) the file
  2473. name is set for the ":read file" command.  This is useful when starting Vim
  2474. without an argument and then doing ":read file" to start editing a file.
  2475. Because the file name was set without really starting to edit that file, you
  2476. are protected from overwriting that file.  This is done by setting the
  2477. "notedited" flag.  You can see if this flag is set with the CTRL-G or ":file"
  2478. command.  It will include "[Not edited]" when the "notedited" flag is set.
  2479. When writing the buffer to the current file name (with ":w!"), the "notedited"
  2480. flag is reset.
  2481.  
  2482. Vim remembers whether you have changed the buffer.  You are protected from
  2483. losing the changes you made.  If you try to quit without writing, or want to
  2484. start editing another file, this will be refused.  In order to overrule this
  2485. protection add a '!' to the command.  The changes will then be lost.  For
  2486. example: ":q" will not work if the buffer was changed, but ":q!" will.  To see
  2487. whether the buffer was changed use the "CTRL-G" command.  The message includes
  2488. the string "[Modified]" if the buffer has been changed.
  2489.  
  2490.  
  2491. 5.2 Editing a file                    *edit_a_file*
  2492.  
  2493.                             *:e* *:edit*
  2494. :e[dit] [+cmd]        Edit the current file, unless changes have been made.
  2495.  
  2496.                             *:edit!*
  2497. :e[dit]! [+cmd]        Edit the current file always.  Discard any changes to
  2498.             the buffer.
  2499.  
  2500.                             *:edit_f*
  2501. :e[dit] [+cmd] {file}    Edit {file}, unless changes have been made.
  2502.  
  2503.                             *:edit!_f*
  2504. :e[dit]! [+cmd] {file}    Edit {file} always.  Discard any changes to the
  2505.             buffer.
  2506.  
  2507. :e[dit] #[count]    Edit the [count]th alternate filename (as shown by
  2508.             :files).  This command does the same as [count] CTRL-^.
  2509.  
  2510.                             *:ex*
  2511. :ex [+cmd] [file]    Same as :edit.  {Vi: go from visual to Ex mode}
  2512.  
  2513.                             *:vi* *:visual*
  2514. :vi[sual] [+cmd] [file]    Same as :edit.  {Vi: go from Ex to visual mode}
  2515.  
  2516.                             *:vie* *:view*
  2517. :vie[w] [+cmd] file    Same as :edit, but set 'readonly' option for this
  2518.             buffer.  {not in Vi}
  2519.  
  2520.                             *CTRL-^*
  2521. [count]CTRL-^        Edit [count]th alternate file (equivalent to ":e
  2522.             #[count]").  Without count this gets you to the
  2523.             previously edited file.  This is a quick way to
  2524.             toggle between two (or more) files.  If the
  2525.             'autowrite' option is on and the buffer was
  2526.             changed, write it.
  2527.  
  2528. ]f                            *]f*
  2529. [f                            *[f* *gf*
  2530. gf            Edit the file whose name is under or after the
  2531.             cursor.  Mnemonic: "goto file".   Uses the 'isfname'
  2532.             option to find out which characters are supposed to be
  2533.             in a file name.  Uses the 'path' variable as a list of
  2534.             directory names to look for the file.  Also looks for
  2535.             the file relative to the current file.  This command
  2536.             fails if the current file cannot be abandoned.  If the
  2537.             name is a hypertext link, that looks like
  2538.             "type://machine/path", only "/path" is used.  For Unix
  2539.             the '~' character is expanded, like in "~user/file".
  2540.             {not in Vi}
  2541.  
  2542.                             *:cd*
  2543. :cd            On non-Unix systems: Print the current directory
  2544.             name.  On Unix systems: Change the current directory
  2545.             to the home directory.
  2546.  
  2547. :cd {path}        Change the current directory to {path}.  Does not
  2548.             change the meaning of an already entered file name,
  2549.             because its full path name is remembered.  On MS-DOS
  2550.             this also changes the active drive.
  2551.  
  2552.                             *:chd* *:chdir*
  2553. :chd[ir] [path]        Same as :cd.
  2554.  
  2555.                             *:pw* *:pwd*
  2556. :pw[d]            Print the current directory name.  {Vi: no pwd}
  2557.  
  2558. These commands are used to start editing a single file.  This means that the
  2559. file is read into the buffer and the current filename is set.  You may use the
  2560. ":cd" command to get to another directory, so you will not have to type that
  2561. directory name in front of the filenames.  One warning: After using ":cd" the
  2562. full path name will be used for reading and writing files.  On some networked
  2563. file systems this may cause problems.  The result of using the full path name
  2564. is that the file names currently in use will remain referring to the same
  2565. file.  Example: If you have a file a:test and a directory a:vim the commands
  2566. ":e test" ":cd vim" ":w" will overwrite the file a:test and not write
  2567. a:vim/test.  But if you do ":w test" the file a:vim/test will be written,
  2568. because you gave a new file name and did not refer to a file name before the
  2569. ":cd".
  2570.  
  2571.                             *:filename*
  2572. Note for systems other than Unix and MS-DOS: When using a command that
  2573. accepts a single file name (like ":edit file") spaces in the file name are
  2574. allowed, but trailing spaces are ignored.  This is useful on systems that
  2575. allow file names with embedded spaces (like the Amiga).  Example: The command
  2576. ":e   Long File Name " will edit the file "Long File Name".  When using a
  2577. command that accepts more than one file name (like ":next file1 file2")
  2578. embedded spaces must be escaped with a backslash.
  2579.  
  2580. On Unix you can also use backticks in the file name, for example:
  2581.     :e `find . -name ver\\*.c -print`
  2582. The backslashes before the star are required to prevent "ver*.c" to be
  2583. expanded by the shell before executing the find program.
  2584.  
  2585. You can use the ":e!" command if you messed up the buffer and want to start
  2586. all over again.  The ":e" command is only useful if you have changed the
  2587. current filename.
  2588.  
  2589. Note that ":e file" will fail if there are changes in the current buffer,
  2590. also when the 'autowrite' option is on.  This is illogical, because with
  2591. other commands (e.g., ":next") the current buffer would be written and
  2592. abandoned, but this behaviour is compatible with Vi.  If you encounter this
  2593. problem, you can use CTRL-^ to jump to the file, because the alternate file
  2594. name is set to the argument of the ":e" command.
  2595.  
  2596.                             *:+cmd*
  2597. The [+cmd] can be used to position the cursor in the newly opened file:
  2598.     +        Start at the last line.
  2599.     +{num}        Start at line {num}.
  2600.     +/{pat}        Start at first line containing {pat}.  {pat} must not
  2601.             contain any spaces.
  2602.     +{command}    Execute {command} after opening the new file.
  2603.             {command} is an Ex command.  It must not contain
  2604.             spaces.
  2605.  
  2606.                             *textmode_io*
  2607. When reading a file when the 'textmode' option is off (default for
  2608. non-MS-DOS) the <NL> character is interpreted as end-of-line.  If 'textmode'
  2609. is on (default for MS-DOS), <CR><NL> is also interpreted as end-of-line.
  2610. Also see |textmode_read|.
  2611.  
  2612. When writing a file when the 'textmode' option is off a <NL> character is
  2613. used to separate lines.  When the 'textmode' option is on <CR><NL> is used.
  2614. Also see |textmode_write|.
  2615.  
  2616. You can read a file with 'textmode' set and write it with 'textmode' reset.
  2617. This will replace all <CR><NL> pairs by <NL>.  If you read a file with
  2618. 'textmode' reset and write with 'textmode' set, all <NL> characters will be
  2619. replaced with <CR><NL>.
  2620.  
  2621. If you start editing a new file and the 'textauto' option is on (which is the
  2622. default), Vim will try to detect whether the lines in the file are separated
  2623. by a single <NL> (as used on Unix and Amiga) or by a <CR><NL> pair (MS-DOS).
  2624. Only when ALL lines end in <CR><NL> the 'textmode' option is set, otherwise it
  2625. is reset.  If the 'textmode' option is set on non-MS-DOS systems the message
  2626. "[textmode]" is shown to remind you that something unusual is happening.  On
  2627. MS-DOS systems you get the message "[notextmode]" if the 'textmode' option is
  2628. not set.
  2629.  
  2630. If the 'textauto' option is off and 'textmode' is on, but while reading a file
  2631. some lines did not end in <CR><NL>, "[CR missing]" will be included in the
  2632. file message.
  2633.  
  2634. Before editing binary, executable or Vim script files you should set the
  2635. 'textmode' and 'textauto' options off.  With 'textmode' on you risk that
  2636. single <NL> characters are unexpectedly replaced with <CR><NL>.  A simple way
  2637. to do this is by starting Vim with the "-b" option.
  2638.  
  2639.  
  2640. 5.3 The argument list                    *argument_list*
  2641.  
  2642. If you give more than one filename when starting Vim, this list is
  2643. remembered as the argument list.  Do not confuse this with the file list,
  2644. which you can see with the ":files" command |:files|.  The argument list was
  2645. already present in Vi, the file list is new in Vim.  The file names in the
  2646. argument list will also be present in the file list (unless they were
  2647. deleted with ":bdel").
  2648.  
  2649. You can use the argument list with the following commands:
  2650.  
  2651.                             *:ar* *:args*
  2652. :ar[gs]            Print the argument list, with the current file in
  2653.             square brackets.
  2654.  
  2655.                             *:argu* *:argument*
  2656. :[count]argu[ment] [count] [+cmd]
  2657.             Edit file [count] in the argument list, unless
  2658.             changes have been made and the 'autowrite' option is
  2659.             off.  {Vi: no such command}
  2660.  
  2661. :[count]argu[ment]! [count] [+cmd]
  2662.             Edit file [count] in the argument list, discard any
  2663.             changes to the current buffer.  {Vi: no such command}
  2664.  
  2665.                             *:n* *:next*
  2666. :[count]n[ext] [+cmd]    Edit [count] next file, unless changes have been
  2667.             made and the 'autowrite' option is off {Vi: no
  2668.             count}.
  2669.  
  2670. :[count]n[ext]! [+cmd]    Edit [count] next file, discard any changes to the
  2671.             buffer {Vi: no count}.
  2672.  
  2673. :ar[gs] [+cmd] {arglist}
  2674. :n[ext] [+cmd] {arglist}
  2675.             Define {arglist} as the new argument list and edit
  2676.             the first one, unless changes have been made and the
  2677.             'autowrite' option is off.
  2678.  
  2679. :ar[gs]! [+cmd] {arglist}
  2680. :n[ext]! [+cmd] {arglist}                *:next_f*
  2681.             Define {arglist} as the new argument list and edit
  2682.             the first one.  Discard any changes to the buffer.
  2683.  
  2684. :[count]N[ext] [count] [+cmd]                *:Next* *:N*
  2685.             Edit [count] previous file in argument list, unless
  2686.             changes have been made and the 'autowrite' option is
  2687.             off {Vi: no count}.
  2688.  
  2689. :[count]N[ext]! [count] [+cmd]
  2690.             Edit [count] previous file in argument list.  Discard
  2691.             any changes to the buffer {Vi: no count}.
  2692.  
  2693. :[count]prev[ious] [count] [+cmd]            *:prev* *:previous*
  2694.             Same as :Next {Vi: only in some versions}
  2695.  
  2696.                             *:rew* *:rewind*
  2697. :rew[ind] [+cmd]    Start editing the first file in the argument list,
  2698.             unless changes have been made and the 'autowrite'
  2699.             option is off.
  2700.  
  2701. :rew[ind]! [+cmd]    Start editing the first file in the argument list.
  2702.             Discard any changes to the buffer.
  2703.  
  2704.                             *:la* *:last*
  2705. :la[st] [+cmd]        Start editing the last file in the argument list,
  2706.             unless changes have been made and the 'autowrite'
  2707.             option is off.  {not in Vi}
  2708.  
  2709. :la[st]! [+cmd]        Start editing the last file in the argument list.
  2710.             Discard any changes to the buffer.  {not in Vi}
  2711.  
  2712.                             *:wn* *:wnext*
  2713. :[count]wn[ext] [+cmd]    Write current file and start editing the [count]
  2714.             next file.  {not in Vi}
  2715.  
  2716. :[count]wn[ext] [+cmd] {file}
  2717.             Write current file to {file} and start editing the
  2718.             [count] next file, unless {file} already exists and
  2719.             the 'writeany' option is off.  {not in Vi}
  2720.  
  2721. :[count]wn[ext]! [+cmd] {file}
  2722.             Write current file to {file} and start editing the
  2723.             [count] next file.  {not in Vi}
  2724.  
  2725. :[count]wN[ext][!] [+cmd] [file]            *:wN* *:wNext*
  2726. :[count]wp[revous][!] [+cmd] [file]            *:wp* *:wprevious*
  2727.             Same as :wnext, but go to previous file instead of
  2728.             next.  {not in Vi}
  2729.  
  2730. The [count] in the commands above defaults to one.  For some commands it is
  2731. possible to use two counts.  The last one (rightmost one) is used.
  2732.  
  2733. For [+cmd] see 5.2 |edit_a_file|.
  2734.  
  2735. The wildcards in the argument list are expanded and the filenames are sorted.
  2736. Thus you can use the command "vim *.c" to edit all the C files.  From within
  2737. Vim the command ":n *.c" does the same.  On Unix you can also use backticks,
  2738. for example:
  2739.     :n `find . -name \\*.c -print`
  2740. The backslashes before the star are required to prevent "*.c" to be expanded
  2741. by the shell before executing the find program.
  2742.  
  2743.                             *arglist_quit*
  2744. You are protected from leaving Vim if you have not been editing the last file
  2745. in the argument list.  This prevents you from forgetting that you were editing
  2746. one out of several files.  To exit anyway try to exit twice.  If there are
  2747. changes in the current buffer this will fail.  You can exit anyway, and save
  2748. any changes, with the ":wq!" command.  To lose any changes use the ":q!"
  2749. command.
  2750.  
  2751. When there is an argument list you can see which file you are editing in the
  2752. title of the window (if there is one and 'title' is on) and with the file
  2753. message you get with the "CTRL-G" command.  You will see something like
  2754.     (file 4 of 11)
  2755. If 'shortmess' contains 'f' it will be
  2756.     (4 of 11)
  2757. If you are not really editing the file at the current position in the argument
  2758. list it will be
  2759.     (file (4) of 11)
  2760. This means that you are position 4 in the argument list, but not editing the
  2761. fourth file in the argument list.  This happens when you do ":e file".
  2762.  
  2763.  
  2764. 5.4 Writing and quitting            *write_quit* *save_file*
  2765.  
  2766.                             *:w* *:write*
  2767. :[range]w[rite][!]    Write the specified lines to the current file.
  2768.  
  2769.                             *:w_f* *:write_f*
  2770. :[range]w[rite]    {file}    Write the specified lines to {file}, unless it
  2771.             already exists and the 'writeany' option is off.
  2772.  
  2773.                             *:w!*
  2774. :[range]w[rite]! {file}    Write the specified lines to {file}.  Overwrite an
  2775.             existing file.
  2776.  
  2777.                             *:w_a* *:write_a*
  2778. :[range]w[rite][!] >>    Append the specified lines to the current file.
  2779.  
  2780. :[range]w[rite][!] >> {file}
  2781.             Append the specified lines to {file}.  '!' forces the
  2782.             write even if file does not exist.
  2783.  
  2784.                             *:w_c* *:write_c*
  2785. :[range]w[rite] !{cmd}    Execute {cmd} with [range] lines as standard input
  2786.             (note the space in front of the '!').  {cmd} is
  2787.             executed like with ":!{cmd}", any '!' is replaced with
  2788.             the previous command |:!|.
  2789.  
  2790. The default [range] for the ":w" command is the whole buffer (1,$).
  2791. If a file name is give with ":w" it becomes the alternate file.  This can be
  2792. used when the write fails and you want to try again later with ":w #".
  2793.  
  2794.  
  2795.                             *:q* *:quit*
  2796. :q[uit]            Quit, unless changes have been made or not editing
  2797.             the last file in the argument list.
  2798.  
  2799. :q[uit]!        Quit always, without writing.
  2800.  
  2801. :cq            Quit always, without writing, and return an error
  2802.             code.  Used for Manx's QuickFix mode (see 5.5
  2803.             |quickfix|).
  2804.  
  2805.                             *:wq*
  2806. :wq            Write the current file and exit (unless editing the
  2807.             last file in the argument list or the file is
  2808.             read-only).
  2809.  
  2810. :wq!            Write the current file and exit.
  2811.  
  2812. :wq {file}        Write to {file}.  Exit if not editing the last
  2813.             file in the argument list.
  2814.  
  2815. :wq! {file}        Write to {file} and exit.
  2816.  
  2817. :[range]wq[!] [file]    Same as above, but only write the lines in [range].
  2818.  
  2819.                             *:x* *:xit*
  2820. :[range]x[it][!] [file]
  2821.             Like ":wq", but write only when changes have been
  2822.             made.
  2823.  
  2824.                             *:exi* *:exit*
  2825. :[range]exi[t][!] [file]
  2826.             Same as :xit.
  2827.  
  2828.                             *ZZ*
  2829. ZZ            Write current file, if modified, and exit (same as
  2830.             ":x").  (Note: If there are several windows for the
  2831.             current file, the file is written if it was modified
  2832.             and the window is closed).
  2833.  
  2834.                             *timestamp*
  2835. Vim remembers the timestamp of the file when you start editing it.  When you
  2836. write a file the timestamp is checked.  If the file has been changed since you
  2837. started editing it, Vim will ask you if you really want to overwrite the file:
  2838.  
  2839.     WARNING: The file has been changed since reading it!!!
  2840.     Do you really want to write to it (y/n)?
  2841.  
  2842. If you hit 'y' Vim will continue writing the file.  If you hit 'n' the write is
  2843. aborted.  If you used ":wq" or "ZZ" Vim will not exit, you will get another
  2844. chance to write the file.
  2845. The message would normally mean that somebody has written to the file after
  2846. the edit session started.  This could be another person, in which case you
  2847. probably want to check if your changes to the file and the changes from the
  2848. other person should be merged.  Write the file under another name and check for
  2849. differences (the "diff" program can be used for this).
  2850. It is also possible that you modified the file yourself, from another edit
  2851. session or with another command (e.g., a filter command).  Then you will know
  2852. which version of the file you want to keep.
  2853.  
  2854.                             *backup*
  2855. If you write to an existing file (but do not append) while the 'backup',
  2856. 'writebackup' or 'patchmode' option is on, a backup of the original file is
  2857. made.  On Unix systems the file is copied, on other systems the file is
  2858. renamed.  After the file has been successfully written and when the
  2859. 'writebackup' option is on and the 'backup' option is off, the backup file is
  2860. deleted.  When the 'patchmode' option is on the backup file may be renamed.
  2861.  
  2862.                             *backup_table*
  2863. 'backup' 'writebackup'    action
  2864.    off         off    no backup made
  2865.    off         on        backup current file, deleted afterwards (default)
  2866.    on         off    delete old backup, backup current file
  2867.    on         on        delete old backup, backup current file
  2868.  
  2869. When the 'backup' option is on, an old backup file (with the same name as the
  2870. new backup file) will be deleted.  If 'backup' is not set, but 'writebackup' is
  2871. set, an existing backup file will not be deleted.  The backup file that is made
  2872. while the file is being written will have a different name.
  2873.  
  2874. The directories given with the 'backupdir' option is used to put the backup
  2875. file in.  (default: same directory as the written file).
  2876.  
  2877. On Unix systems:
  2878. When you write to an existing file, that file is truncated and then filled
  2879. with the new text.  This means that protection bits, owner and symbolic links
  2880. are unmodified.  The backup file however, is a new file, owned by the user who
  2881. edited the file.  The group of the backup is set to the group of the original
  2882. file.  If this fails, the protection bits for the group are made the same as
  2883. for others.
  2884.  
  2885. If the creation of a backup file fails, the write is not done.  If you want
  2886. to write anyway add a '!' to the command.
  2887.  
  2888.                             *write_fail*
  2889. If the writing of the new file fails, you have to be careful not to lose
  2890. your changes AND the original file.  If there is no backup file and writing
  2891. the new file failed, you have already lost the original file! DON'T EXIT VIM
  2892. UNTIL YOU WRITE OUT THE FILE! If a backup was made, it is put back in place
  2893. of the original file (if possible).  If you exit Vim, and lose the changes
  2894. you made, the original file will mostly still be there.  If putting back the
  2895. original file fails, there will be an error message telling you that you
  2896. lost the original file.
  2897.  
  2898.                             *textmode_write*
  2899. If the 'textmode' option is on <CR><NL> is used for end-of-line.  This is
  2900. default for MS-DOS, Win32 and OS/2.  On other systems the message "[textmode]"
  2901. is shown to remind you that an usual end-of-line marker was used.  If the
  2902. 'textmode' is not set NL is used for end-of-line.  On MS-DOS, Win32 and OS/2
  2903. the message "[notextmode]" is shown.  See also |textmode_io| and the
  2904. 'textmode' and 'textauto' options.
  2905.  
  2906.  
  2907. 5.5 Using the QuickFix mode                *quickfix*
  2908.  
  2909. Vim has a special mode to speedup the edit-compile-edit cycle.  This is
  2910. inspired by the quickfix option of the Manx's Aztec C compiler on the Amiga.
  2911. The idea is to save the error messages from the compiler in a file and use
  2912. Vim to jump to the errors one by one.  You can then examine each problem and
  2913. fix it, without having to remember all the error messages.
  2914.  
  2915. If you are using Manx's Aztec C compiler on the Amiga you should do the
  2916. following:
  2917. - Set the CCEDIT environment variable with the command
  2918.     mset "CCEDIT=vim -e"
  2919. - Compile with the -qf option.  If the compiler finds any errors, Vim is
  2920.   started and the cursor is positioned on the first error.  The error message
  2921.   will be displayed on the last line.  You can go to other errors with the
  2922.   commands mentioned below.  You can fix the errors and write the file(s).
  2923. - If you exit Vim normally the compiler will re-compile the same file.  If you
  2924.   exit with the :cq command, the compiler will terminate.  Do this if you
  2925.   cannot fix the error, or if another file needs to be compiled first.
  2926.  
  2927. If you are using another compiler you should save the error messages in a
  2928. file and start Vim with "vim -e filename".  An easy way to do this is with
  2929. the ":make" command (see below).  The 'errorformat' option should be set to
  2930. match the error messages from your compiler (see below).
  2931.  
  2932. The following commands can be used if you are in QuickFix mode:
  2933.  
  2934.                             *:cc*
  2935. :cc [nr]        Display error [nr].  If [nr] is omitted, the same
  2936.             error is displayed again.  {not in Vi}
  2937.  
  2938.                             *:cn* *:cnext*
  2939. :[count]cn[ext]        Display the [count] next error in the list that
  2940.             includes a file name.  If there are no file names at
  2941.             all, go the the [count] next error.  {not in Vi}
  2942.  
  2943. :[count]cN[ext]                *:cp* *:cprevious* *:cN* *:cNext*
  2944. :[count]cp[revious]    Display the [count] previous error in the list that
  2945.             includes a file name.  If there are no file names at
  2946.             all, go the the [count] previous error.  {not in Vi}
  2947.  
  2948.                             *:cq* *:cquit*
  2949. :cq[uit]        Quit Vim with an error code, so that the compiler
  2950.             will not compile the same file again.  {not in Vi}
  2951.  
  2952.                             *:cf* *:cfile*
  2953. :cf[ile] [errorfile]    Read the error file and jump to the first error.
  2954.             This is done automatically when Vim is started with
  2955.             the -e option.  You can use this command when you
  2956.             keep Vim running while compiling.  If you give the
  2957.             name of the errorfile, the 'errorfile' option will
  2958.             be set to [errorfile] {not in Vi}
  2959.  
  2960.                             *:cl* *:clist*
  2961. :cl[ist]        List all errors that inlcude a file name.  {not in Vi}
  2962.  
  2963. :cl[ist]!        List all errors.  {not in Vi}
  2964.  
  2965.                             *:mak* *:make*
  2966. :mak[e] [arguments]    1. If the 'autowrite' option is on, write any changed
  2967.                buffers
  2968.             2. Any existing 'errorfile' is deleted.
  2969.             3. The program given with the 'makeprg' option is
  2970.                started (default "make") with the optional
  2971.                [arguments] and the output is saved in
  2972.                'errorfile' (for Unix it is also echoed on the
  2973.                screen).
  2974.             4. The 'errorfile' is then read and the first error
  2975.                is jumped to.
  2976.             5. The 'errorfile' is deleted.
  2977.             {not in Vi}
  2978.  
  2979. The name of the file can be set with the 'errorfile' option.  The default is
  2980. "AztecC.Err" for the Amiga and "errors.vim" for other systems.  The format of
  2981. the file from the Aztec compiler is:
  2982.  
  2983.     filename>linenumber:columnnumber:errortype:errornumber:errormessage
  2984.  
  2985.     filename    name of the file in which the error was detected
  2986.     linenumber    line number where the error was detected
  2987.     columnnumber    column number where the error was detected
  2988.     errortype    type of the error, normally a single 'E' or 'W'
  2989.     errornumber    number of the error (for lookup in the manual)
  2990.     errormessage    description of the error
  2991.  
  2992.                             *errorformat*
  2993. Another compiler is likely to use a different format.  You should set the
  2994. 'errorformat' option to a scanf-like string that describes the format.
  2995. First, you need to know how scanf works.  Look in the documentation of your
  2996. C compiler.  Vim will understand eight conversion characters.  Others are
  2997. invalid.
  2998.     %f        file name (finds a string)
  2999.     %l        line number (finds a number)
  3000.     %c        column number (finds a number)
  3001.     %t        error type (finds a single character)
  3002.     %n        error number (finds a number)
  3003.     %m        error message (finds a string)
  3004.     %*<conv>    any scanf non-assignable conversion
  3005.     %%        the single '%' character
  3006.  
  3007. Examples:
  3008. %f>%l:%c:%t:%n:%m"            for the AztecC.Err file
  3009. %f:%l:\ %t%*[^0123456789]%n:\ %m    for Manx/Aztec C error messages
  3010.                     (scanf() doesn't understand [0-9])
  3011. %f\ %l\ %t%*[^0-9]%n:\ %m        for SAS C
  3012. \"%f\"\\,%*[^0-9]%l:\ %m        for generic C compilers
  3013. %f:%l:\ %m                for GCC
  3014. %f(%l)\ :\ %*[^:]:\ %m            old SCO C compiler (pre-OS5)
  3015. %f(%l)\ :\ %t%*[^0-9]%n:\ %m        idem, with error type and number
  3016. %f:%l:\ %m,In\ file\ included\ from\ %f:%l:,\^I\^Ifrom\ %f:%l%m
  3017.                     for GCC, with some extras
  3018.  
  3019. Note the backslash in front of a space and double quote.  It is required for
  3020. the :set command.  There are two backslashes in front of a comma, one for the
  3021. :set command and one to avoid recognizing the comma as a separator of error
  3022. formats.
  3023.  
  3024. The "%f" and "%m" conversions have to detect the end of the string.  They
  3025. should be followed by a character that cannot be in the string.  Everything
  3026. up to that character is included in the string.  Be careful: "%f%l" will
  3027. include everything up to the first '%' in the file name.  If the "%f" or "%m"
  3028. is at the end, everything up to the end of the line is included.
  3029.  
  3030. To be able to detect output from several compilers, several format patterns
  3031. may be put in 'errorformat', separated by commas (note: blanks after the comma
  3032. are ignored).  The first pattern that has a complete match is used.  If no
  3033. match is found, matching parts from the last one will be used, although the
  3034. file name is removed and the error message is set to the whole message.  If
  3035. there is a pattern that may match output from several compilers (but not in a
  3036. right way), put it after one that is more restrictive.  To include a comma in
  3037. a pattern precede it with a backslash (you have to type two in a set command).
  3038. To include a backslash itself give two backslashes (you have to type four in a
  3039. set command).
  3040.  
  3041. If a line is detected that does not completely match the 'errorformat', the
  3042. whole line is put in the error message and the entry is marked "not valid"
  3043. These lines are skipped with the ":cn" and ":cp" commands (unless there is
  3044. no valid line at all).  You can use ":cl!" to display all the error messages.
  3045.  
  3046. If the error format does not contain a file name Vim cannot switch to the
  3047. correct file.  You will have to do this by hand.
  3048.  
  3049. If you have a compiler that produces error messages that do not fit in the
  3050. format string, you could write a program that translates the error messages
  3051. into this format.  You can use this program with the ":make" command by
  3052. changing the 'makeprg' option.  For example:
  3053.     ":set mp=make\ \\\|&\ error_filter".
  3054. The backslashes before the pipe character are required to avoid it to be
  3055. recognized as a command separator.  The backslash before each space is
  3056. required for the set command.
  3057.  
  3058.                         *:make_makeprg*
  3059. The ":make" command executes the command given with the 'makeprg' option.
  3060. This is done by passing the command to the shell given with the 'shell'
  3061. option.  This works almost like typing
  3062.  
  3063.     ":!{makeprg} [arguments] {shellpipe} {errorfile}".
  3064.  
  3065. {makeprg} is the string given with the 'makeprg' option.  Any command can be
  3066. used, not just "make".  Characters '%' and '#' are expanded as usual on a
  3067. command line.  You can use "#<" to insert the current filename without
  3068. extension, for example ":set makeprg=make\ #<.o".
  3069.  
  3070. [arguments] is anything that is typed after ":make".
  3071. {shellpipe} is the 'shellpipe' option.
  3072. {errorfile} is the 'errorfile' option.
  3073.  
  3074. The 'shellpipe' option defaults to ">" for the Amiga, MS-DOS and Win32.  This
  3075. means that the output of the compiler is saved in a file and not shown on the
  3076. screen directly.  For Unix "| tee" is used.  The compiler output is shown on
  3077. the screen and saved in a file the same time.  Depending on the shell used
  3078. "|& tee" or "2>&1| tee" is the default, so stderr output will be included.
  3079.  
  3080. There are some restrictions to the Quickfix mode on the Amiga.  The
  3081. compiler only writes the first 25 errors to the errorfile (Manx's
  3082. documentation does not say how to get more).  If you want to find the others,
  3083. you will have to fix a few errors and exit the editor.  After recompiling,
  3084. up to 25 remaining errors will be found.
  3085.  
  3086. On the Amiga, if Vim was started from the compiler, the :sh and :! commands
  3087. will not work, because Vim is then running in the same process as the
  3088. compiler and these two commands may guru the machine then.
  3089.  
  3090. If you insert or delete lines, mostly the correct error location is still
  3091. found because hidden marks are used (Manx's Z editor does not do this).
  3092. Sometimes, when the mark has been deleted for some reason, the message "line
  3093. changed" is shown to warn you that the error location may not be correct.  If
  3094. you quit Vim and start again the marks are lost and the error locations may
  3095. not be correct anymore.
  3096.  
  3097.  
  3098. 5.6 Editing binary files                *edit_binary*
  3099.  
  3100. Although Vim was made to edit text files, it is possible to edit binary
  3101. files.  The "-b" Vim argument (b for binary) sets some options for
  3102. editing binary files ('binary' on, 'textwidth' to 0, 'textmode' and
  3103. 'textauto' off, 'modeline' off, 'expandtab' off).  Setting the 'binary'
  3104. option has the same effect.  Don't forget to do this before reading the file.
  3105.  
  3106. There are a few things to remember when editing binary files:
  3107. - When editing executable files the number of characters must not change.
  3108.   Use only the "R" or "r" command to change text.  Do not delete characters
  3109.   with "x" or by backspacing.
  3110. - Set the 'textwidth' option to 0.  Otherwise lines will unexpectedly be
  3111.   split in two.
  3112. - When there are not many end-of-line characters, the lines will become very
  3113.   long.  If you want to edit a line that does not fit on the screen reset the
  3114.   'wrap' option.  Horizontal scrolling is used then.  If a line becomes too
  3115.   long (more than about 32767 characters on the Amiga, much more on 32-bit
  3116.   systems, see |limits|) you cannot edit that line.  The line will be split
  3117.   when reading the file.  It is also possible that you get an "out of memory"
  3118.   error when reading the file.
  3119. - Make sure the 'textmode' and 'textauto' options are off before loading the
  3120.   file.  In 'textmode' both <CR><NL> and <NL> are considered to end a line
  3121.   and when the file is written the <NL> will be replaced with <CR><NL>.  The
  3122.   'modelines' option should also be off, because there may be a string like
  3123.   ":vi:" in the file that would give unpredictable results.
  3124. - <Nul> characters are shown on the screen as ^@.  You can enter them with
  3125.   "CTRL-V CTRL-@" or "CTRL-V 000" {Vi cannot handle <Nul> characters in the
  3126.   file}
  3127. - To insert a <NL> character in the file split up a line.  When writing the
  3128.   buffer to a file a <NL> will be written for the end of line.
  3129. - Vim normally appends an end-of-line character at the end of the file if
  3130.   there is none.  Setting the 'binary' option prevents this.  If you want to
  3131.   add the final end-of-line, set the 'endofline' option.  You can also read the
  3132.   value of this option to see if there was an end-of-line character for the
  3133.   last line (you cannot see this in the text).
  3134.  
  3135.  
  3136. 5.7 Automatic commands                    *autocommand*
  3137.  
  3138. You can specify commands to be executed automatically for when reading or
  3139. writing a file, when entering or leaving a buffer or window, and when exiting
  3140. Vim.  For example, 'cindent' can be set for files matching *.c, and unset
  3141. otherwise.  Autocommands can be used to edit compressed files.  These commands
  3142. are normally put in your .vimrc or .exrc file.  {All this is not in Vi}
  3143.  
  3144. WARNING: Using autocommands is very powerful, but may lead to unexpected side
  3145. effects.  Be careful not to destroy your text.
  3146. - It's a good idea to first do some testing on a copy of a file first.  For
  3147.   example: If you use autocommands to decompress a file when starting to edit
  3148.   it, make sure that the autocommands for compressing when writing work
  3149.   correctly.
  3150. - Be prepared for an error halfway through (e.g., disk full).  Vim will mostly
  3151.   be able to undo the changes to the buffer, but you may have to clean up the
  3152.   changes to other files by hand (e.g., compress a file that has been
  3153.   decompressed).
  3154. - If the BufRead* events allow you to edit a compressed file, the FileRead*
  3155.   events should do the same (to be able to do recovery in some rare cases).
  3156.   It's a good idea to use the same autocommands for the File* and Buf* events
  3157.   when possible.
  3158.  
  3159. The autocommand feature is only included if Vim has been compiled with AUTOCMD
  3160. defined.  If the output of ":version" contains "+autocmd" it is included (this
  3161. is the default), if it contains "-autocmd" then the autocommand feature
  3162. doesn't work.
  3163.  
  3164. Note: This command cannot be followed by another command, since any '|' is
  3165. considered part of the command.
  3166.  
  3167.                             *:au* *:autocmd*
  3168. :au[tocmd] {event} {pat} {cmd}
  3169.             Add {cmd} to the list of commands that will be
  3170.             automatically executed on {event} for a file matching
  3171.             {pat}.  It is not added if it is already there (as may
  3172.             happen when .vimrc is sourced again).  The order of
  3173.             entering {cmd} and {pat} is important.
  3174.  
  3175. :au[tocmd] {event} {pat}
  3176.             Show the auto-commands associated with {event} and
  3177.             {pat}.
  3178.  
  3179. :au[tocmd] * {pat}    Show the auto-commands associated with pat} for all
  3180.             events.
  3181.  
  3182. :au[tocmd] {event}    Show all auto-commands for {event}.
  3183.  
  3184. :au[tocmd]        Show all auto-commands.
  3185.  
  3186. :au[tocmd]! {event} {pat} {cmd}
  3187.             Remove all auto-commands associated with {event} and
  3188.             {pat}, and add the command {cmd}.
  3189.  
  3190. :au[tocmd]! {event} {pat}
  3191.             Remove all auto-commands associated with {event} and
  3192.             {pat}.
  3193.  
  3194. :au[tocmd]! * {pat}    Remove all auto-commands associated with {pat} for all
  3195.             events.
  3196.  
  3197. :au[tocmd]! {event}    Remove ALL auto-commands for {event}.
  3198.  
  3199. :au[tocmd]!        Remove ALL auto-commands.
  3200.  
  3201.                             *:do* *:doautocmd*
  3202. :do[autocmd] {event} [fname]
  3203.             Apply the autocommands matching [fname] (default:
  3204.             current file name) for {event} to the current buffer.
  3205.             This can be used when the current file name does not
  3206.             match the right pattern, after changing settings, or
  3207.             to execute autocommands for a certain event.
  3208.  
  3209. These events are recognized.  Case is ignored, for example "BUFread" and
  3210. "bufread" can be used instead of "BufRead".
  3211.  
  3212.                             *BufNewFile*
  3213. BufNewFile            When starting to edit a file that doesn't
  3214.                 exist.  Can be used to read in a skeleton
  3215.                 file.
  3216.                             *BufReadPre*
  3217. BufReadPre            When starting to edit a new buffer, before
  3218.                 reading the file into the buffer.  Not used
  3219.                 when starting to edit a new file.
  3220.                         *BufRead* *BufReadPost*
  3221. BufRead or BufReadPost        When starting to edit a new buffer, after
  3222.                 reading the file into the buffer, before
  3223.                 executing the modelines.  This does NOT work
  3224.                 for ":r file".  Not used when starting to edit
  3225.                 a new file.
  3226.                             *FileReadPre*
  3227. FileReadPre            Before reading a file with a ":read" command.
  3228.                             *FileReadPost*
  3229. FileReadPost            After reading a file with a ":read" command.
  3230.                 Note that the '[ and '] marks are set to the
  3231.                 first and last line of the read, this can be
  3232.                 used to operate on the just read lines.
  3233.                             *FilterReadPre*
  3234. FilterReadPre            Before reading a file from a filter command.
  3235.                 The file name of the current buffer is used to
  3236.                 match with the pattern, not the name of the
  3237.                 temporary file that is the output of the
  3238.                 filter command.
  3239.                             *FilterReadPost*
  3240. FilterReadPost            After reading a file from a filter command.
  3241.                 Like FilterReadPre, the file name of the
  3242.                 current buffer is used.
  3243.                         *BufWrite* *BufWritePre*
  3244. BufWrite or BufWritePre        Before writing the whole buffer to a file.
  3245.                             *BufWritePost*
  3246. BufWritePost            After writing the whole buffer to a file
  3247.                 (should undo the commands for BufWritePre).
  3248.                             *FileWritePre*
  3249. FileWritePre            Before writing to a file, when not writing the
  3250.                 whole buffer.
  3251.                             *FileWritePost*
  3252. FileWritePost            After writing to a file, when not writing the
  3253.                 whole buffer.
  3254.                             *FileAppendPre*
  3255. FileAppendPre            Before appending to a file.
  3256.                             *FileAppendPost*
  3257. FileAppendPost            After appending to a file.
  3258.                             *FilterWritePre*
  3259. FilterWritePre            Before writing a file for a filter command.
  3260.                 The file name of the current buffer is used to
  3261.                 match with the pattern, not the name of the
  3262.                 temporary file that is the input for the
  3263.                 filter command.
  3264.                             *FilterWritePost*
  3265. FilterWritePost            After writing a file for a filter command.
  3266.                 Like FilterWritePre, the file name of the
  3267.                 current buffer is used.
  3268.                             *BufEnter*
  3269. BufEnter            After entering a buffer.  Useful for setting
  3270.                 options for a file type.  Also executed when
  3271.                 starting to edit a buffer, after the
  3272.                 BufReadPost autocommands.
  3273.                             *BufLeave*
  3274. BufLeave            Before leaving to another buffer.  Also when
  3275.                 leaving or closing the current window and the
  3276.                 new current window is not for the same buffer.
  3277.                             *WinEnter*
  3278. WinEnter            After entering another window.  Not done for
  3279.                 the first window, when Vim is just started.
  3280.                 Useful for setting the window height.
  3281.                 If the window is for another buffer, the
  3282.                 BufEnter autocommands are executed after the
  3283.                 WinEnter autocommands.
  3284.                             *WinLeave*
  3285. WinLeave            Before leaving to another window.  If the
  3286.                 window to be entered is for a different
  3287.                 buffer, the BufLeave autocommands are executed
  3288.                 before the WinLeave autocommands.
  3289.                             *VimLeave*
  3290. VimLeave            Before exiting Vim, just before writing the
  3291.                 .viminfo file.  There is no VimEnter event,
  3292.                 because you can use the .vimrc for that.
  3293.  
  3294. For READING FILES there are three possible pairs of events, only one pair is
  3295. used at a time:
  3296. BufNewFile            starting to edit a non-existant file
  3297. BufReadPre    BufReadPost    starting to edit an existing file
  3298. FilterReadPre    FilterReadPost    read the temp file with filter output
  3299. FileReadPre    FileReadPost    any other file read
  3300.  
  3301. Before the *ReadPre event the '[ mark is set to the line just above where the
  3302. new lines will be inserted.
  3303. Before the *ReadPost event the '[ mark is set to the first line that was just
  3304. read, the '] mark to the last line.
  3305. Careful: '[ and '] will change when using commands that change the buffer.
  3306. "<afile>" can be used for the file name that is being read, in commands where
  3307. a file name is expected (where you can also use "%" for the current file
  3308. name) |:<afile>|.
  3309.  
  3310. Examples for reading compressed files:
  3311.   :autocmd! BufReadPre,FileReadPre   *.gz set bin
  3312.   :autocmd  BufReadPost,FileReadPost *.gz '[,']!gunzip
  3313.   :autocmd  BufReadPost,FileReadPost *.gz set nobin
  3314.  
  3315. NOTE: When using the examples given, any existing autocommands for the same
  3316. event/pattern combination will be removed, because of the '!'.
  3317.  
  3318. For WRITING FILES there are four possible pairs of events, only one pair is
  3319. used at a time:
  3320. BufWritePre    BufWritePost    writing the whole buffer
  3321. FilterWritePre    FilterWritePost    writing to the temp file with filter input
  3322. FileAppendPre    FileAppendPost    appending to a file
  3323. FileWritePre    FileWritePost    any other file write
  3324.  
  3325. Note that the *WritePost commands should undo any changes to the buffer that
  3326. were caused by the *WritePre commands, otherwise writing the file will have
  3327. the side effect of changing the buffer.
  3328.  
  3329. Before the *WritePre event the '[ mark is set to the first line that will be
  3330. written, the '] mark to the last line.
  3331. Careful: '[ and '] will change when using commands that change the buffer.
  3332. "<afile>" can be used for the file name that is being written, in commands
  3333. where a file name is expected (where you can also use "%" for the current file
  3334. name) |:<afile>|.
  3335.  
  3336. Examples for writing compressed files:
  3337.   :autocmd! BufWritePost,FileWritePost    *.gz !mv <afile> <afile>:r
  3338.   :autocmd  BufWritePost,FileWritePost    *.gz !gzip <afile>:r
  3339.  
  3340.   :autocmd! FileAppendPre        *.gz !gunzip <afile>
  3341.   :autocmd  FileAppendPre        *.gz !mv <afile>:r <afile>
  3342.   :autocmd! FileAppendPost        *.gz !mv <afile> <afile>:r
  3343.   :autocmd  FileAppendPost        *.gz !gzip <afile>:r
  3344.  
  3345. ("<afile>:r" is the file name without the extension, see |:_%:|)
  3346.  
  3347. The commands executed for the BufNewFile, BufRead/BufReadPost, BufWritePost,
  3348. FileAppendPost and VimLeave events do not set or reset the changed flag of the
  3349. buffer.  When you decompress the buffer with the BufReadPost autocommands, you
  3350. can still exit with ":q".  When you use ":undo" in BufWritePost to undo the
  3351. changes made by BufWritePre commands, you can still do ":q" (this also makes
  3352. "ZZ" work).
  3353.  
  3354. To execute Normal mode commands from an autocommand, use the ":normal"
  3355. command.  Use with care!  If the Normal mode command is not finished, the user
  3356. needs to type characters (e.g., after ":normal m" you need to type a mark
  3357. name).
  3358.  
  3359. If you want the buffer not to be modified after changing it, reset the
  3360. 'modified' option.  This makes it possible to exit the buffer with ":q"
  3361. instead of ":q!".
  3362.  
  3363. Autocommands do not nest.  If you use ":r" or ":w" in an autocommand, the
  3364. BufRead and BufWrite autocommands are not executed for those commands.  It's
  3365. also not possible to use the ":au" command in an autocommand (that could be a
  3366. self-modifying command!).
  3367.  
  3368. There is currently no way to disable the autocommands.  If you want to write a
  3369. file without executing the autocommands for that type of file, write it under
  3370. another name and rename it with a shell command.
  3371.  
  3372. Note: When doing a ":read file" command and the last line in the file does not
  3373. have an end-of-line character, this is remembered.  When executing the
  3374. FileReadPost autocommands and the same line is written again as the last line
  3375. in a file, no end-of-line character is written if 'binary' is set.  This makes
  3376. a filter command on the just read lines write the same file as was read.
  3377.  
  3378. Multiple patterns may be given separated by commas.  Here are some examples:
  3379.  
  3380.   :autocmd BufRead   *        set tw=79 nocin ic infercase fo=2croq
  3381.   :autocmd BufRead   .letter    set tw=72 fo=2tcrq
  3382.   :autocmd BufEnter  .letter    set dict=/usr/lib/dict/words
  3383.   :autocmd BufLeave  .letter    set dict=
  3384.   :autocmd BufRead,BufNewFile   *.c,*.h    set tw=0 cin noic
  3385.   :autocmd BufEnter  *.c,*.h    abbr FOR for(i = 0; i < 3; i++)^M{^M}^[O
  3386.   :autocmd BufLeave  *.c,*.h    unabbr FOR
  3387.  
  3388. For makefiles (makefile, Makefile, imakefile, makefile.unix, etc.):
  3389.  
  3390.   :autocmd BufEnter  ?akefile*    set include=^s\=include
  3391.   :autocmd BufLeave  ?akefile*    set include&
  3392.  
  3393. To always start editing C files at the first function:
  3394.  
  3395.   :autocmd BufRead   *.c,*.h    1;/^{
  3396.  
  3397. Without the "1;" above, the search would start from wherever the file was
  3398. entered, rather than from the start of the file.
  3399.  
  3400. To read a skeleton file for new C files:
  3401.  
  3402.   :autocmd BufNewFile  *.c    0r ~/.skeleton.c
  3403.   :autocmd BufNewFile  *.h    0r ~/.skeleton.h
  3404.  
  3405. To insert the current date and time in a *.html file when writing it:
  3406.  
  3407. :autocmd BufWritePre,FileWritePre *.html ks|1,20g/Last modification: /normal f:lD:read !date^MkJ's
  3408.  
  3409. (to insert the ^M type CTRL-V CTRL-M)
  3410. You need to have a line "Last modification: <date time>" in the first 20 lines
  3411. of the file for this to work.  The <date time> (and anything in the same line
  3412. after it) will be replaced with the current date and time.  Explanation:
  3413.     ks        mark current position with mark 's'
  3414.     1,20g/pattern/    find lines that contain the pattern
  3415.     normal f:    find the ':'
  3416.     lD        delete the old date and time
  3417.     !date^M        read the current date and time into the next line
  3418.     kJ        Join the date and time with the previous line
  3419.     's        return the cursor to the old position
  3420.  
  3421. When entering :autocmd on the command line, completion of events and command
  3422. names may be done (with <Tab>, CTRL-D, etc.) where appropriate.
  3423.  
  3424. All matching auto-commands will be executed in the order that they were
  3425. specified.  It is recommended that your first auto-command be used for all
  3426. files by using "*" as the file pattern.  This means that you can define
  3427. defaults you like here for any settings, and if there is another matching
  3428. auto-command it will override these.  But if there is no other matching
  3429. auto-command, then at least your default settings are recovered (if entering
  3430. this file from another for which auto-commands did match).  Note that "*" will
  3431. also match files starting with ".", unlike Unix shells.
  3432.  
  3433. Normally the file pattern is tested for a match against just the tail part of
  3434. the file name (without its leading directory path), but if a path separator
  3435. character (eg '/' on Unix) appears in the pattern, then it will be tested
  3436. against the full file name.  For example:
  3437.  
  3438.   :autocmd BufRead */vim/src/*    set wrap
  3439.  
  3440.  
  3441. 6. Cursor motions                    *cursor_motions*
  3442. =================
  3443.  
  3444. These commands move the cursor position.  If the new position is off of the
  3445. screen, the screen is scrolled to show the cursor (see also 'scrolljump' and
  3446. 'scrolloff' options).
  3447.  
  3448.                             *operator*
  3449. The motion commands can be used after an operator command, to have the command
  3450. operate on the text that was moved over.  That is the text between the cursor
  3451. position before and after the motion.  Operators are generally used to delete
  3452. or change text.  The following operators are available:
  3453.     |c|    c    change
  3454.     |d|    d    delete
  3455.     |y|    y    yank into register (does not change the text)
  3456.     |~|    ~    swap case (only if 'tildeop' is set)
  3457.     |g~|    g~    swap case
  3458.     |gu|    gu    make lower case
  3459.     |gU|    gU    make upper case
  3460.     |!|    !    filter through an external program
  3461.     |=|    =    filter through 'equalprg' or C-indenting if empty
  3462.     |Q|    Q    text formatting (obsolete)
  3463.     |gq|    gq    text formatting
  3464.     |>|    >    shift right
  3465.     |<|    <    shift left
  3466. If the motion includes a count and the operator also had a count before it,
  3467. the two counts are multiplied.  For example: "2d3w" deletes six words.
  3468.     The operator either affects whole lines, or the characters between the
  3469. start and end position.  Generally, motions that move between lines affect
  3470. lines (are linewise), and motions that move within a line affect characters.
  3471. However, there are some exceptions.
  3472.     A character motion is either inclusive or exclusive. When inclusive,
  3473. the start and end position of the motion are included in the operation.
  3474. When exclusive, the last character towards the end of the buffer is not
  3475. included.  Linewise motions always include the start and end position.
  3476.     Which motions are linewise, inclusive or exclusive is mentioned
  3477. below.  There are however, two general exceptions:
  3478. 1. If the motion is exclusive and the end of the motion is in column 1, the
  3479.    end of the motion is moved to the end of the previous line and the motion
  3480.    becomes inclusive.  Example: "}" ends at the first line after a paragraph,
  3481.    but "V}" will not include that line.
  3482. 2. If the motion is exclusive, the end of the motion is in column 1 and the
  3483.    start of the motion was at or before the first non-blank in the line, the
  3484.    motion becomes linewise.  Example: If a paragraph begins with some blanks
  3485.    and you do "d}" while standing on the first non-blank, all the lines of
  3486.    the paragraph are deleted, including the blanks.  If you do a put now, the
  3487.    deleted lines will be inserted below the cursor position.
  3488.  
  3489. Instead of first giving the operator and then a motion you can use Visual
  3490. mode: mark the start of the text with "v", move the cursor to the end of the
  3491. text that is to be affected and then hit the operator.  The text between the
  3492. start and the cursor position is highlighted, so you can see what text will
  3493. be operated upon.  This allows much more freedom, but requires more key
  3494. strokes and has limited redo functionality.  See the chapter on Visual mode
  3495. |Visual_mode|.
  3496.  
  3497. If you want to know where you are in the file use the "CTRL-G" command
  3498. |CTRL-G| or the "g CTRL-G command |g_CTRL-G|.  If you set the 'ruler' option,
  3499. the cursor position is continuously shown in the status line (which slows down
  3500. Vim a little).
  3501.  
  3502. NOTE: Experienced users prefer the hjkl keys because they are always right
  3503. under their fingers.  Beginners often prefer the arrow keys, because they
  3504. do not know what the hjkl keys do.  The mnemonic value of hjkl is clear from
  3505. looking at the keyboard.  Think of j as an arrow pointing downwards.
  3506.  
  3507.  
  3508. 6.1 Left-right motions                    *left_right_motions*
  3509.  
  3510. h        or                    *h*
  3511. <Left>        or                    *<Left>*
  3512. CTRL-H        or                    *CTRL-H* *<BS>*
  3513. <BS>            [count] characters to the left (exclusive).
  3514.             Note: If you prefer <BS> to delete a character, use
  3515.             the mapping:
  3516.                 :map CTRL-V<BS>        X
  3517.             (to enter "CTRL-V<BS>" type the CTRL-V key, followed
  3518.             by the <BS> key)
  3519.             See |:fixdel| if the <BS> key does not do what you
  3520.             want.
  3521.  
  3522. l        or                    *l*
  3523. <Right>        or                    *<Right>* *<Space>*
  3524. <Space>            [count] characters to the right (exclusive).
  3525.  
  3526.                             *0*
  3527. 0            To the first character of the line (exclusive).  When
  3528.             moving up or down, stay in same screen column (if
  3529.             possible).
  3530.  
  3531.                             *<Home>*
  3532. <Home>            To the first character of the line (exclusive).  When
  3533.             moving up or down, stay in same text column (if
  3534.             possible).  Works like "1|", which differs from "0"
  3535.             when the line starts with a <Tab>.  {not in Vi}
  3536.  
  3537.                             *^*
  3538. ^            To the first non-blank character of the line
  3539.             (exclusive).
  3540.  
  3541.                             *$* *<End>*
  3542. $  or <End>        To the end of line and [count - 1] lines downward
  3543.             (inclusive).
  3544.  
  3545.                             *g0* *g<Home>*
  3546. g0 or g<Home>        When lines wrap ('wrap on): To the first character of
  3547.             the screen line (exclusive).  Differs from "0" when a
  3548.             line is wider than the screen.
  3549.             When lines don't wrap ('wrap' off): To the leftmost
  3550.             character of the current line that is on the screen.
  3551.             Differs from "0" when the first character of the line
  3552.             is not on the screen.  {not in Vi}
  3553.  
  3554.                             *g^*
  3555. g^            When lines wrap ('wrap' on): To the first non-blank
  3556.             character of the screen line (exclusive).  Differs
  3557.             from "^" when a line is wider than the screen.
  3558.             When lines don't wrap ('wrap' off): To the leftmost
  3559.             non-blank character of the current line that is on the
  3560.             screen.  Differs from "^" when the first non-blank
  3561.             character of the line is not on the screen.  {not in
  3562.             Vi}
  3563.  
  3564.                             *g$* *g<End>*
  3565. g$ or g<End>        When lines wrap ('wrap' on): To the last character of
  3566.             the screen line and [count - 1] screen lines downward
  3567.             (inclusive).  Differs from "$" when a line is wider
  3568.             than the screen.
  3569.             When lines don't wrap ('wrap' off): To the righmost
  3570.             character of the current line that is visible on the
  3571.             screen.  Differs from "$" when the last character of
  3572.             the line is not on the screen or when a count is used.
  3573.             {not in Vi}
  3574.  
  3575.                             *bar*
  3576. |            To screen column [count] in the current line
  3577.             (exclusive).
  3578.  
  3579.                             *f*
  3580. f{char}            To [count]'th occurrence of {char} to the right.  The
  3581.             cursor is placed on {char} (inclusive).
  3582.  
  3583.                             *F*
  3584. F{char}            To the [count]'th occurrence of {char} to the left.
  3585.             The cursor is placed on {char} (inclusive).
  3586.  
  3587.                             *t*
  3588. t{char}            Till before [count]'th occurrence of {char} to the
  3589.             right.  The cursor is placed on the character left of
  3590.             {char} (inclusive).
  3591.  
  3592.                             *T*
  3593. T{char}            Till after [count]'th occurrence of {char} to the
  3594.             left.  The cursor is placed on the character right of
  3595.             {char} (inclusive).
  3596.  
  3597.                             *;*
  3598. ;            Repeat latest f, t, F or T [count] times.
  3599.  
  3600.                             *,*
  3601. ,            Repeat latest f, t, F or T in opposite direction
  3602.             [count] times.
  3603.  
  3604. These commands move the cursor to the specified column in the current line.
  3605. They stop at the first column and at the end of the line, except "$", which
  3606. may move to one of the next lines.  See 'whichwrap' option to make some of the
  3607. commands move accross line boundaries.
  3608.  
  3609.  
  3610. 6.2 Up-down motions                    *up_down_motions*
  3611.  
  3612. k        or                    *k*
  3613. <Up>        or                    *<Up>* *CTRL-P*
  3614. CTRL-P            [count] lines upward (linewise).
  3615.  
  3616. j        or                    *j*
  3617. <Down>        or                    *<Down>*
  3618. CTRL-J        or                    *CTRL-J*
  3619. <NL>        or                    *<NL>* *CTRL-N*
  3620. CTRL-N            [count] lines downward (linewise).
  3621.  
  3622. gk        or                    *gk* *g<Up>*
  3623. g<Up>            [count] display lines upward (exclusive).  Differs
  3624.             from 'k' when lines wrap.  {not in Vi}
  3625.  
  3626. gj        or                    *gj* *g<Down>*
  3627. g<Down>            [count] display lines downward (exclusive).  Differs
  3628.             from 'j' when lines wrap.  {not in Vi}
  3629.  
  3630.                             *-*
  3631. -  <minus>        [count] lines upward, on the first non-blank
  3632.             character (linewise).
  3633.  
  3634. +        or                    *+*
  3635. CTRL-M        or                    *CTRL-M* *<CR>*
  3636. <CR>            [count] lines downward, on the first non-blank
  3637.             character (linewise).
  3638.  
  3639.                             *_*
  3640. _  <underscore>        [count] - 1 lines downward, on the first non-blank
  3641.             character (linewise).
  3642.  
  3643. <C-End>        or                    *G* *<C-End>*
  3644. G            Goto line [count], default last line, on the first
  3645.             non-blank character (linewise).  If 'startofline' not
  3646.             set, keep the same column.
  3647.  
  3648. <C-Home>    or                    *gg* *<C-Home>*
  3649. gg            Goto line [count], default first line, on the first
  3650.             non-blank character (linewise).  If 'startofline' not
  3651.             set, keep the same column.
  3652.  
  3653. :[range]        Set the cursor on the (last) specified line number
  3654.             (cannot be used with an operator).
  3655.  
  3656.                             *N%*
  3657. {count}%        Go to {count} percentage in the file, on the first
  3658.             non-blank in the line (linewise).  To compute the new
  3659.             line number this formula is used: {count} *
  3660.             number-of-lines / 100.  See also 'startofline'
  3661.             option.  {not in Vi}
  3662.  
  3663. These commands move to the specified line.  They stop when reaching the first
  3664. or the last line.  The first two commands put the cursor in the same column
  3665. (if possible) as it was after the last command that changed the column,
  3666. except after the "$" command, then the cursor will be put on the last
  3667. character of the line.
  3668.  
  3669.  
  3670. 6.3 Word motions                    *word_motions*
  3671.  
  3672. <S-Right>    or                    *<S-Right>* *w*
  3673. w            [count] words forward (exclusive).
  3674.  
  3675.                             *W*
  3676. W            [count] WORDS forward (exclusive).
  3677.  
  3678.                             *e*
  3679. e            Forward to the end of word [count] (inclusive).
  3680.  
  3681.                             *E*
  3682. E            Forward to the end of WORD [count] (inclusive).
  3683.  
  3684. <S-Left>    or                    *<S-Left>* *b*
  3685. b            [count] words backward (exclusive).
  3686.  
  3687.                             *B*
  3688. B            [count] WORDS backward (exclusive).
  3689.  
  3690.                             *ge*
  3691. ge            Backward to the end of word [count] (inclusive).
  3692.  
  3693.                             *gE*
  3694. gE            Backward to the end of WORD [count] (inclusive).
  3695.  
  3696.                             *word* *WORD*
  3697. These commands move over words or WORDS.  A word consists of a sequence of
  3698. letters, digits and underscores, or a sequence of other non-blank
  3699. characters, separated with white space (spaces, tabs, end of line).  A WORD
  3700. consists of a sequence of non-blank characters, separated with white space.
  3701. An empty line is also considered to be a word and a WORD.
  3702.  
  3703. Special case: "cw" and "cW" are treated like "ce" and "cE" if the cursor is
  3704. on a non-blank.  This is because "cw" is interpreted as change-word, and a
  3705. word does not include the following white space.  {Vi: "cw" when on a blank
  3706. followed by other blanks changes only the first blank; this is probably a
  3707. bug, because "dw" deletes all the blanks}
  3708.  
  3709. Another special case: When using the "w" motion in combination with an
  3710. operator and the last word moved over is at the end of a line, the end of
  3711. that word becomes the end of the operated text, not the first word in the
  3712. next line.
  3713.  
  3714. The original Vi implementation of "e" is buggy.  For example, the "e" command
  3715. will stop on the first character of a line if the previous line was empty.
  3716. But when you use "2e" this does not happen.  In Vim "ee" and "2e" are the
  3717. same, which is more logical.  However, this causes a small incompatibility
  3718. between Vi and Vim.
  3719.  
  3720.  
  3721. 6.4 Text object motions                    *object_motions*
  3722.  
  3723.                             *(*
  3724. (            [count] sentences backward (exclusive).
  3725.  
  3726.                             *)*
  3727. )            [count] sentences forward (exclusive).
  3728.  
  3729.                             *{*
  3730. {            [count] paragraphs backward (exclusive).
  3731.  
  3732.                             *}*
  3733. }            [count] paragraphs forward (exclusive).
  3734.  
  3735.                             *]]*
  3736. ]]            [count] sections forward or to the next '{' in the
  3737.             first column.  When used after an operator, then the
  3738.             '}' in the first column.  (linewise).
  3739.  
  3740.                             *][*
  3741. ][            [count] sections forward or to the next '}' in the
  3742.             first column (linewise).
  3743.  
  3744.                             *[[*
  3745. [[            [count] sections backward or to the previous '{' in
  3746.             the first column (linewise).
  3747.  
  3748.                             *[]*
  3749. []            [count] sections backward or to the previous '}' in
  3750.             the first column (linewise).
  3751.  
  3752. These commands move over three kinds of text objects.
  3753.  
  3754.                             *sentence*
  3755. A sentence is defined as ending at a '.', '!' or '?' followed by either the
  3756. end of a line, or by a space.  {Vi: two spaces} Any number of closing ')',
  3757. ']', '"' and ''' characters my appear after the '.', '!' or '?' before the
  3758. spaces or end of line.  A paragraph and section boundary is also a sentence
  3759. boundary.
  3760.  
  3761.                             *paragraph*
  3762. A paragraph begins after each empty line, and also at each of a set of
  3763. paragraph macros, specified by the pairs of characters in the 'paragraphs'
  3764. option.  The default is "IPLPPPQPP LIpplpipbp", which corresponds to the
  3765. macros ".IP", ".LP", etc.  (These are nroff macros, so the dot must be in the
  3766. first column).  A section boundary is also a paragraph boundary.  Note that
  3767. this does not include a '{' or '}' in the first column.
  3768.  
  3769.                             *section*
  3770. A section begins after a form-feed in the first column and at each of a set
  3771. of section macros, specified by the pairs of characters in the 'sections'
  3772. option.  The default is "SHNHH HUnhsh".
  3773.  
  3774. The "]" and "[" commands stop at the '{' or <}" in the first column.  This is
  3775. useful to find the start or end of a function in a C program.  Note that the
  3776. first character of the command determines the search direction and the
  3777. second character the type of brace found.
  3778.  
  3779.  
  3780. 6.5 Text object selection                *object_select*
  3781.  
  3782.                             *v_a*
  3783. a            select [count] words (see |word|).  {not in Vi}
  3784.  
  3785.                             *v_A*
  3786. A            select [count] WORDS (see |WORD|).  {not in Vi}
  3787.  
  3788.                             *v_s*
  3789. s            select [count] sentences (see |sentence|).  {not in Vi}
  3790.  
  3791.                             *v_p*
  3792. p            select [count] paragraphs (see |paragraph|).  {not in
  3793.             Vi}
  3794.  
  3795.                             *v_S*
  3796. S            select [count] blocks, from "[count] [(" to the
  3797.             matching ')' (see |[(|).  {not in Vi}
  3798.  
  3799.                             *v_P*
  3800. P            select [count] blocks, from "[count] [{" to the
  3801.             matching '}' (see |[{|).  {not in Vi}
  3802.  
  3803. These object selection commands can only be used in Visual mode and after an
  3804. operator.
  3805.  
  3806. When used after an operator:
  3807. For non-block objects:
  3808.     The operator applies to the object and the white space after the
  3809.     object.  If there is no white space after the object or when the
  3810.     cursor was in the white space before the object, the white space
  3811.     before the object is included.
  3812. For a block object:
  3813.     The operator applies to the block excluding the surrounding braces.
  3814.     If the cursor was on one of the braces (or on the indent before '{' or
  3815.     '}) they are included.
  3816.  
  3817. When used in Visual mode:
  3818. When start and end of the Visual area are the same (just after typing "v"):
  3819.     One object is selected, the same as for using an operator.
  3820. When start and end of the Visual area are not the same:
  3821.     For non-block objects the area is extended by one object or the white
  3822.     space up to the next object.  The direction in which this happens
  3823.     depends on which side of the Visual area the cursor is.  For the block
  3824.     objects the block is extended one level outwards.
  3825.  
  3826. For illustration, here is a list of delete commands, grouped from small to big
  3827. objects.  Note that for a single character and a whole line the existing vi
  3828. movement commands are used.
  3829.     "dl"    delete character (alias: "x")        |dl|
  3830.     "da"    delete word                *da*
  3831.     "dA"    delete WORD (see |WORD|)        *dA*
  3832.     "dd"    delete line                |dd|
  3833.     "ds"    delete sentence                *ds*
  3834.     "dS"    delete '(' ')' block            *dS*
  3835.     "dp"    delete paragraph            *dp*
  3836.     "dP"    delete '{' '}' block            *dP*
  3837.  
  3838. Note the difference between using a movement command and an object.  The
  3839. movement command operates from here (cursor position) to where the movement
  3840. takes us.  When using an object the whole object is operated upon, no matter
  3841. where on the object the cursor is.  For example, compare "dw" and "da": "dw"
  3842. deletes from the cursor position to the start of the next word, "da" deletes
  3843. the word under the cursor and the space after or before it.
  3844.  
  3845.  
  3846. 6.6 Pattern searches                    *pattern_searches*
  3847.  
  3848.                             */*
  3849. /{pattern}[/]<CR>    Search forward for the [count]'th occurrence of
  3850.             {pattern} (exclusive).
  3851.  
  3852. /{pattern}/{offset}<CR>    Search forward for the [count]'th occurrence of
  3853.             {pattern} and go {offset} lines up or down (see
  3854.             below).  (linewise).
  3855.  
  3856.                             */<CR>*
  3857. /<CR>            Search forward for the [count]'th latest used
  3858.             pattern with latest used {offset}.
  3859.  
  3860. //{offset}<CR>        Search forward for the [count]'th latest used
  3861.             pattern with new {offset}.  If {offset} is empty no
  3862.             offset is used.
  3863.  
  3864.                             *?*
  3865. ?{pattern}[?]<CR>    Search backward for the [count]'th previous
  3866.             occurrence of {pattern} (exclusive).
  3867.  
  3868. ?{pattern}?{offset}<CR>    Search backward for the [count]'th previous
  3869.             occurrence of {pattern} and go {offset} lines up or
  3870.             down (see below) (linewise).
  3871.  
  3872.                             *?<CR>*
  3873. ?<CR>            Search backward for the [count]'th latest used
  3874.             pattern with latest used {offset}.
  3875.  
  3876. ??{offset}<CR>        Search backward for the [count]'th latest used
  3877.             pattern with new {offset}.  If {offset} is empty no
  3878.             offset is used.
  3879.  
  3880.                             *n*
  3881. n            Repeat the latest "/" or "?" [count] times.  {Vi: no
  3882.             count}
  3883.  
  3884.                             *N*
  3885. N            Repeat the latest "/" or "?" [count] times in
  3886.             opposite direction.  {Vi: no count}
  3887.  
  3888.                             *star*
  3889. *            Search forward for the [count]'th occurrence of the
  3890.             keyword after or under the cursor (exclusive).  Only
  3891.             whole keywords are search for, like with the command
  3892.             "/\<keyword\>".  If there is no keyword after or
  3893.             under the cursor, any non-blank word is used to
  3894.             search for.  {not in Vi}
  3895.  
  3896.                             *#*
  3897. #            Same as "*", but search backward.  The English pound
  3898.             sign (character 163) also works.  {not in Vi}
  3899.  
  3900.                             *gstar*
  3901. g*            Like "*", but don't put "\<" and "\>" around the word.
  3902.             This makes the search also find matches that are not a
  3903.             whole word.  {not in Vi}
  3904.  
  3905.                             *g#*
  3906. g#            Like "#", but don't put "\<" and "\>" around the word.
  3907.             This makes the search also find matches that are not a
  3908.             whole word.  {not in Vi}
  3909.  
  3910.             HINT: If you want to search for something else than a
  3911.             whole word, you could use these mappings, to search
  3912.             for Visually highlighted text:
  3913.                 :vmap / y/<C-R>"<CR>
  3914.                 :vmap ? y?<C-R>"<CR>
  3915.             (<> notation, see |<>|).
  3916.  
  3917.                             *gd*
  3918. gd            Goto local Declaration.  When the cursor is on a local
  3919.             variable, this command will jump to its declaration.
  3920.             First a search is made for the end of the previous
  3921.             function, just like "[]".  If it is not found the
  3922.             search stops in line 1.  From this position a search is
  3923.             made for the keyword under the cursor, like with "*",
  3924.             but lines that look like a comment are ignored (see
  3925.             'comments' option).  Note that this is not guaranteed
  3926.             to work, Vim does not really check the syntax, it only
  3927.             searches for a match with the keyword.  If included
  3928.             files also need to be searched use the commands listed
  3929.             in |include_search|.  {not in Vi}
  3930.  
  3931.                             *gD*
  3932. gD            Goto global Declaration.  When the cursor is on a
  3933.             global variable that is defined in the file, this
  3934.             command will jump to its declaration.  This works just
  3935.             like "gd", except that the search for the keyword
  3936.             always starts in line 1.  {not in Vi}
  3937.  
  3938.                             *CTRL-C*
  3939. CTRL-C            Interrupt current (search) command.
  3940.  
  3941. While typing the search pattern the current match will be shown if the
  3942. 'incsearch' option is on.
  3943.  
  3944. These commands search for the specified pattern.  With "/" and "?" an
  3945. additional offset may be given.  There are two types of offsets: line offsets
  3946. and character offsets.  {the character offsets are not in Vi}
  3947.  
  3948.                             *search_offset*
  3949. The offset gives the cursor position relative to the found match:
  3950.     [num]    [num] lines downwards, in column 1
  3951.     +[num]    [num] lines downwards, in column 1
  3952.     -[num]    [num] lines upwards, in column 1
  3953.     e[+num]    [num] characters to the right of the end of the match
  3954.     e[-num]    [num] characters to the left of the end of the match
  3955.     s[+num]    [num] characters to the right of the start of the match
  3956.     s[-num]    [num] characters to the left of the start of the match
  3957.     b[+num]    [num] characters to the right of the start (begin) of the match
  3958.     b[-num]    [num] characters to the left of the start (begin) of the match
  3959.  
  3960. If a '-' or '+' is given but [num] is omitted, a count of one will be used.
  3961. When including an offset with 'e', the search becomes inclusive (the
  3962. character the cursor lands on is included in operations).
  3963.  
  3964. Examples:
  3965.  
  3966. pattern            cursor position
  3967. /test/+1        one line below "test", in column 1
  3968. /test/e            on the last t of "test"
  3969. /test/s+2        on the 's' of "test"
  3970. /test/b-3        three characters before "test"
  3971.  
  3972. If one of these commands is used after an operator, the characters between
  3973. the cursor position before and after the search is affected.  However, if a
  3974. line offset is given, the whole lines between the two cursor positions are
  3975. affected.
  3976.  
  3977.                             *//;*
  3978. A very special offset is ';' followed by another search command.  For example:
  3979.  
  3980.     /test 1/;/test
  3981.     /test.*/+1;?ing?
  3982.  
  3983. The first one first finds the next occurence of "test 1", and then the first
  3984. occurence of "test" after that.
  3985.  
  3986. This is like executing two search commands after each other, except that:
  3987. - It can be used as a single motion command after an operator.
  3988. - The direction for a following "n" or "N" command comes from the first
  3989.   search command.
  3990. - When an error occurs the cursor is not moved at all.
  3991.  
  3992. The last used <pattern> and <offset> are remembered.  They can be used to
  3993. repeat the search, possibly in another direction or with another count.  Note
  3994. that two patterns are remembered: one for 'normal' search commands and one
  3995. for the substitute command ":s".  Each time an empty <pattern> is given, the
  3996. previously used <pattern> is used.
  3997.  
  3998. In Vi the ":tag" command sets the last search pattern when the tag is searched
  3999. for.  In Vim this is not done, the previous search pattern is still remembered,
  4000. unless the 't' flag is present in 'cpoptions'.  The search pattern is always
  4001. put in the search history.
  4002.  
  4003. If the 'wrapscan' option is on (which is the default), searches wrap around
  4004. the end of the buffer.  If 'wrapscan' is not set, the backward search stops
  4005. at the beginning and the forward search stops at the end of the buffer.  If
  4006. 'wrapscan' is set and the pattern was not found the error message "pattern
  4007. not found" is given, and the cursor will not be moved.  If 'wrapscan' is not
  4008. set the message becomes "search hit BOTTOM without match" when searching
  4009. forward, or "search hit TOP without match" when searching backward.  If
  4010. wrapscan is set and the search wraps around the end of the file the message
  4011. "search hit TOP, continuing at BOTTOM" or "search hit BOTTOM, continuing at
  4012. TOP" is given when searching backwards or forwards respectively.  This can be
  4013. switched off by setting the 's' flag in the 'shortmess' option.  The highlight
  4014. method 'w' is used for this message (default: standout).
  4015.  
  4016. The "*" and "#" commands search for the keyword currently under the cursor.
  4017. If there is no keyword under the cursor, the first one to the right is used.
  4018. This keyword may only contain letters and characters in 'iskeyword'.  Note
  4019. that if you type with ten fingers, the characters are easy to remember: the
  4020. "#" is under your left hand middle finger (search to the left and up) and
  4021. the "*" is under your right hand middle finger (search to the right and
  4022. down).  If there is no keyword under or after the cursor, a search is done
  4023. for any word under or after the cursor.  Blanks (<Tab>s and/or <Space>s) are
  4024. then recognized as delimiters for the word.
  4025.  
  4026.  
  4027. The definition of a pattern:                *search_pattern*
  4028.  
  4029. Patterns may contain special characters, depending on the setting of the
  4030. 'magic' option.
  4031.  
  4032. 1. A pattern is one or more branches, separated by "\|".  It matches anything
  4033.    that matches one of the branches.  Example: "foo\|bar" matches "foo" and
  4034.    "bar".
  4035.  
  4036. 2. A branch is one or more pieces, concatenated.  It matches a match for the
  4037.    first, followed by a match for the second, etc.  Example: "foo[0-9]bar",
  4038.    first match "foo", then a digit and then "bar".
  4039.  
  4040. 3. A piece is an atom, possibly followed by:
  4041.       'magic'    'nomagic'
  4042.       option    option
  4043.     *      \*        matches 0 or more of the preceding atom
  4044.     \+      \+        matches 1 or more of the preceding atom {not
  4045.                 in Vi}
  4046.     \=      \=        matches 0 or 1 of the preceding atom {not in
  4047.                 Vi}
  4048.     Examples:
  4049.        .*      .\*        matches anything, also empty string
  4050.        ^.\+$      ^.\+$        matches any non-empty line
  4051.        foo\=      foo\=        matches "fo" and "foo"
  4052.  
  4053.  
  4054. 4. An atom can be:
  4055.    - One of these five:
  4056.       magic    nomagic
  4057.     ^      ^        at beginning of pattern, matches start of
  4058.                 line
  4059.     $      $        at end of pattern or in front of "\|",
  4060.                 matches end of line
  4061.     .      \.        matches any single character
  4062.     \<      \<        matches the beginning of a word
  4063.     \>      \>        matches the end of a word
  4064.     \i      \i        matches any identifier character (see
  4065.                 'isident' option) {not in Vi}
  4066.     \I      \I        like "\i", but excluding digits {not in Vi}
  4067.     \k      \k        matches any keyword character (see
  4068.                 'iskeyword' option) {not in Vi}
  4069.     \K      \K        like "\k", but excluding digits {not in Vi}
  4070.     \f      \f        matches any file name character (see
  4071.                 'isfname' option) {not in Vi}
  4072.     \F      \F        like "\f", but excluding digits {not in Vi}
  4073.     \p      \p        matches any printable character (see
  4074.                 'isprint' option) {not in Vi}
  4075.     \P      \P        like "\p", but excluding digits {not in Vi}
  4076.     \e      \e        <Esc>
  4077.     \t      \t        <Tab>
  4078.     \r      \r        <CR>
  4079.     \b      \b        <BS>
  4080.     ~      \~        matches the last given substitute pattern
  4081.     \(\)      \(\)        A pattern enclosed by escaped parentheses
  4082.                 (e.g., "\(^a\)") matches that pattern
  4083.     x      x        A single character, with no special meaning,
  4084.                 matches itself
  4085.     \x      \x        A backslash followed by a single character,
  4086.                 with no special meaning, matches the single
  4087.                 character
  4088.     []      \[]        A range. This is a sequence of characters
  4089.                 enclosed in "[]" or "\[]".  It matches any
  4090.                 single character from the sequence.  If the
  4091.                 sequence begins with "^", it matches any
  4092.                 single character NOT in the sequence.  If two
  4093.                 characters in the sequence are separated by
  4094.                 '-', this is shorthand for the full list of
  4095.                 ASCII characters between them.  E.g., "[0-9]"
  4096.                 matches any decimal digit.  To include a
  4097.                 literal "]" in the sequence, make it the
  4098.                 first character (following a possible "^").
  4099.                 E.g., "[]xyz]" or "[^]xyz]".  To include a
  4100.                 literal '-', make it the first or last
  4101.                 character.
  4102.  
  4103. If the 'ignorecase' option is on, the case of letters is ignored.
  4104.  
  4105. It is impossible to have a pattern that contains a line break.
  4106.  
  4107. Examples:
  4108. ^beep(            Probably the start of the C function "beep".
  4109.  
  4110. [a-zA-Z]$        Any alphabetic character at the end of a line.
  4111.  
  4112. \<\I\i        or
  4113. \(^\|[^a-zA-Z0-9_]\)[a-zA-Z_]\+[a-zA-Z0-9_]*
  4114.             A C identifier (will stop in front of it).
  4115.  
  4116. \(\.$\|\. \)        A period followed by end-of-line or a space.
  4117.             Note that "\(\. \|\.$\)" does not do the same,
  4118.             because '$' is not end-of-line in front of '\)'.
  4119.             This was done to remain Vi-compatible.
  4120.  
  4121. [.!?][])"']*\($\|[ ]\)    A search pattern that finds the end of a sentence,
  4122.             with almost the same definition as the ")" command.
  4123.  
  4124. Technical detail:
  4125. <Nul> characters in the file are stored as <NL> in memory.  In the display
  4126. they are shown as "^@".  The translation is done when reading and writing
  4127. files.  To match a <Nul> with a search pattern you can just enter CTRL-@ or
  4128. "CTRL-V 000".  This is probably just what you expect.  Internally the
  4129. character is replaced with a <NL> in the search pattern.  What is unusual is
  4130. that typing CTRL-V CTRL-J also inserts a <NL>, thus also searches for a
  4131. <Nul> in the file.  {Vi cannot handle <Nul> characters in the file at all}
  4132.  
  4133.  
  4134. 6.7 Various motions                *various_motions*
  4135.  
  4136.                         *m*
  4137. m<a-zA-Z>        Set mark <a-zA-Z> at cursor position (does not move
  4138.             the cursor, this is not a motion command).
  4139.  
  4140.                         *:ma* *:mark*
  4141. :[range]ma[rk] <a-zA-Z>    Set mark <a-zA-Z> at last line number in [range],
  4142.             column 0.  Default is cursor line.
  4143.  
  4144.                         *:k*
  4145. :[range]k<a-zA-Z>    Same as :mark, but the space before the mark name can
  4146.             be omitted.
  4147.  
  4148.                         *'* *'a*
  4149. '<a-z>            To the first non-blank character on the line with
  4150.             mark <a-z> (linewise).
  4151.                         *'A* *'0*
  4152. '<A-Z0-9>        To the first non-blank character on the line with
  4153.             mark <A-Z0-9> in the correct file (linewise when in
  4154.             same file, not a motion command when in other file).
  4155.             {not in Vi}
  4156.  
  4157.                         *`* *`a*
  4158. `<a-z>            To the mark <a-z> (exclusive).
  4159.                         *`A* *`0*
  4160. `<A-Z0-9>        To the mark <A-Z0-9> in the correct file (exclusive
  4161.             when in same file, not a motion command when in
  4162.             other file).  {not in Vi}
  4163.  
  4164.                         *:marks*
  4165. :marks            List all the current marks (not a motion command).
  4166.             {not in Vi}
  4167.  
  4168. :marks {arg}        List the marks that are mentioned in {arg} (not a
  4169.             motion command).  For example:
  4170.                 :marks aB
  4171.             to list marks 'a' and 'B'.  {not in Vi}
  4172.  
  4173. A mark is not visible in any way.  It is just a position in the file that is
  4174. remembered.  Do not confuse marks with named registers, they are totally
  4175. unrelated.
  4176.  
  4177. 'a - 'z        lowercase marks, valid within one file
  4178. 'A - 'Z        uppercase marks, also called file marks, valid between files
  4179. '0 - '9        numbered marks, set from .viminfo file
  4180.  
  4181. Lowercase marks 'a to 'z are remembered as long as the file remains in the
  4182. buffer list.  If you remove the file from the buffer list, change a character
  4183. in a line or delete a line that contains a mark, that mark is erased.
  4184. Lowercase marks can be used in combination with operators.  For example: "d't"
  4185. deletes the lines from the cursor position to mark 't'.  Hint: Use mark 't' for
  4186. Top, 'b' for Bottom, etc..  Lowercase marks are restored when using undo and
  4187. redo.
  4188.  
  4189. Uppercase marks 'A to 'Z include the file name.  {Vi: no uppercase marks} You
  4190. can use them to jump from file to file.  You can only use an uppercase mark
  4191. with an operator if the mark is in the current file.  The line number of the
  4192. mark remains correct, even if you insert/delete lines or edit another file for
  4193. a moment.  When the 'viminfo' option is not empty, uppercase marks are kept in
  4194. the .viminfo file.  See |viminfo_file_marks|.
  4195.  
  4196. Numbered marks '0 to '9 are quite different.  They can not be set directly.
  4197. They are only present when using a viminfo file |viminfo_file|.  Basically '0
  4198. is the location of the cursor when you last exited Vim, '1 the last but one
  4199. time, etc.  See |viminfo_file_marks|.
  4200.  
  4201.                             *'[*
  4202. '[            To the first non-blank character on the first line
  4203.             of the previously operated, inserted or putted text.
  4204.             {not in Vi}
  4205.  
  4206.                             *`[*
  4207. `[            To the first character of the previously operated,
  4208.             inserted or putted text.  {not in Vi}
  4209.  
  4210.                             *']*
  4211. ']            To the first non-blank character on the last line of
  4212.             the previously operated, inserted  or putted text.
  4213.             {not in Vi}
  4214.  
  4215.                             *`]*
  4216. `]            To the last character of the previously operated,
  4217.             inserted or putted text. {not in Vi}
  4218.  
  4219. After executing an operator the Cursor is put at the beginning of the text
  4220. that was operated upon.  After a put command ("p" or "P") the cursor is
  4221. sometimes placed at the first inserted line and sometimes on the last inserted
  4222. character.  The four commands above put the cursor at either end.  Example:
  4223. After yanking 10 lines you want to go to the last one of them: "10Y']".  After
  4224. inserting several lines with the "p" command you want to jump to the lowest
  4225. inserted line: "p']".  This also works for text that has been inserted.
  4226.  
  4227. Note: After deleting text, the start and end positions are the same, except
  4228. when using blockwise Visual mode.  These commands do not work when no
  4229. operator or put command has been used yet in the current file.
  4230.  
  4231.                             *'<*
  4232. '<            To the first non-blank character on the first line
  4233.             of the last selected Visual area.  {not in Vi}.
  4234.  
  4235.                             *`<*
  4236. `<            To the first character of the last selected Visual
  4237.             area.  {not in Vi}.
  4238.  
  4239.                             *'>*
  4240. '>            To the first non-blank character on the last line
  4241.             of the last selected Visual area.  {not in Vi}.
  4242.  
  4243.                             *`>*
  4244. `>            To the last character of the last selected Visual
  4245.             area.  {not in Vi}.
  4246.  
  4247.                             *''*
  4248. ''            To the first non-blank character of the line where
  4249.             the cursor was before the latest jump (linewise).
  4250.  
  4251.                             *``*
  4252. ``            To the position before latest jump (exclusive).
  4253.  
  4254.                             *'"*
  4255. '"            To the first non-blank character of the line where
  4256.             the cursor was the last time the current buffer was
  4257.             exited (linewise).  {not in Vi}.
  4258.  
  4259.                             *`"*
  4260. `"            To the cursor position when last exiting the current
  4261.             buffer (exclusive).  {not in Vi}.
  4262.  
  4263. A "jump" is one of the following commands: "'", "`", "G", "/", "?", "n",
  4264. "N", "%", "(", ")", "[[", "]]", "{", "}", ":s", ":tag", "L", "M", "H" and
  4265. the commands that start editing a new file.  If you make the cursor "jump"
  4266. with one of these commands, the position of the cursor before the jump is
  4267. remembered.  You can return to that position with the "''" and "``" command,
  4268. unless the line containing that position was changed or deleted.
  4269.  
  4270.                             *CTRL-O*
  4271. CTRL-O            Go to [count] Older cursor position in jump list
  4272.             (not a motion command).  {not in Vi}
  4273.  
  4274. <Tab>        or                    *CTRL-I* *<Tab>*
  4275. CTRL-I            Go to [count] newer cursor position in jump list
  4276.             (not a motion command).  {not in Vi}
  4277.  
  4278.                             *:ju* *:jumps*
  4279. :ju[mps]        Print the jump list (not a motion command).  {not in
  4280.             Vi}
  4281.  
  4282.                             *jumplist*
  4283. Jumps are remembered in a jump list.  With the CTRL-O and CTRL-I command you
  4284. can go to cursor positions before older jumps, and back again.  Thus you can
  4285. move up and down the list.
  4286.  
  4287. For example, after three jump commands you have this jump list:
  4288.  
  4289.  jump line  file
  4290.    1     1  -current-
  4291.    2    70  -current-
  4292.    3  1154  -current-
  4293. >
  4294.  
  4295. You are currently in line 1167.  If you then use the CTRL-O command, the
  4296. cursor is put in line 1154.  This results in:
  4297.  
  4298.  jump line  file
  4299.    1     1  -current-
  4300.    2    70  -current-
  4301. >  3  1154  -current-
  4302.    4  1167  -current-
  4303.  
  4304. The pointer will be set at the last used jump position.  The next CTRL-O
  4305. command will use the entry above it, the next CTRL-I command will use the
  4306. entry below it.  If the pointer is below the last entry, this indicates that
  4307. you did not use a CTRL-I or CTRL-O before.  In this case the CTRL-O command
  4308. will cause the cursor position to be added to the jump list, so you can get
  4309. back to the position before the CTRL-O.  In this case this is line 1167.
  4310.  
  4311. With more CTRL-O commands you will go to lines 70 and 1.  If you use CTRL-I
  4312. you can go back to 1154 and 1167 again.
  4313.  
  4314. If you use a jump command, the current line number is inserted at the end of
  4315. the jump list.  If the same line was already in the jump list, it is removed.
  4316. The result is that when repeating CTRL-O you will get back to old positions
  4317. only once.
  4318.  
  4319. After the CTRL-O command that got you into line 1154 you could give another
  4320. jump command (e.g., "G").  The jump list would then become:
  4321.  
  4322.  jump line  file
  4323.    1     1  -current-
  4324.    2    70  -current-
  4325.    3  1167  -current-
  4326.    4  1154  -current-
  4327. >
  4328.  
  4329. The line numbers will be adjusted for deleted and inserted lines.  This fails
  4330. if you stop editing a file without writing, like with ":n!".
  4331.  
  4332.                             *%*
  4333. %            Find the next item in this line after or under the
  4334.             cursor and jump to its match (inclusive).  Items can
  4335.             be:
  4336.             ([{}])        parenthesis or (curly/square) brackets
  4337.             /* */        start or end of C-style comment
  4338.             #if, #ifdef, #else, #elif, #endif
  4339.                     C preprocessor conditionals
  4340.             Parens and braces preceded with a backslash are
  4341.             ignored.  When the '%' character is not present in
  4342.             'cpoptions', parens and braces inside quotes are
  4343.             ignored, unless the number of parens/braces in a line
  4344.             is uneven and this line and the previous one does not
  4345.             end in a backslash.  No count is allowed ({count}%
  4346.             jumps to a line {count} percentage down the file).
  4347.             Using '%' on #if/#else/#endif makes the movement
  4348.             linewise.
  4349.  
  4350.                         *[(*
  4351. [(            go to [count] previous unmatched '('.  {not in Vi}
  4352.  
  4353.                         *[{*
  4354. [{            go to [count] previous unmatched '{'.  {not in Vi}
  4355.  
  4356.                         *])*
  4357. ])            go to [count] next unmatched ')'.  {not in Vi}
  4358.  
  4359.                         *]}*
  4360. ]}            go to [count] next unmatched '}'.  {not in Vi}
  4361.  
  4362. The above four commands can be used to go to the start or end of the current
  4363. code block.  It is like doing "%" on the '(', ')', '{' or '}' at the other
  4364. end of the code block, but you can do this from anywhere in the code block.
  4365. Very useful for C programs.  Example: When standing on "case x:", "[{" will
  4366. bring you back to the switch statement.
  4367.  
  4368.                         *[#*
  4369. [#            go to [count] previous unmatched "#if" or "#else".
  4370.             {not in Vi}
  4371.  
  4372.                         *]#*
  4373. ]#            go to [count] next unmatched "#else" or "#endif".  {not
  4374.             in Vi}
  4375.  
  4376. These two commands work in C programs that contain #if/#else/#endif
  4377. constructs.  It brings you to the start or end of the #if/#else/#endif where
  4378. the current line is included.  You can then use "%" to go to the matching line.
  4379.  
  4380.                         *[star* *[/*
  4381. [*  or  [/        go to [count] previous start of a C comment "/*".  {not
  4382.             in Vi}
  4383.  
  4384.                         *]star* *]/*
  4385. ]*  or  ]/        go to [count] next end of a C comment "*/".  {not
  4386.             in Vi}
  4387.  
  4388.  
  4389.                         *H*
  4390. H            To line [count] from top (Home) of screen (default:
  4391.             first line on the screen) on the first non-blank
  4392.             character (linewise).  See also 'startofline' option.
  4393.             Cursor is adjusted for 'scrolloff' option.
  4394.  
  4395.                         *M*
  4396. M            To Middle line of screen, on the first non-blank
  4397.             character (linewise).  See also 'startofline' option.
  4398.  
  4399.                         *L*
  4400. L            To line [count] from bottom of screen (default: Last
  4401.             line on the screen) on the first non-blank character
  4402.             (linewise).  See also 'startofline' option.
  4403.             Cursor is adjusted for 'scrolloff' option.
  4404.  
  4405. <LeftMouse>        Moves to the position on the screen where the mouse
  4406.             click is (inclusive).  See also |<LeftMouse>|.  If the
  4407.             position is in a status line, that window is made the
  4408.             active window and the cursor is not moved.  {not in Vi}
  4409.  
  4410.  
  4411. 7. Scrolling                        *scrolling*
  4412. ============
  4413.  
  4414. Move edit window (the part of the buffer that you see) downwards (this means
  4415. that more lines downwards in the text buffer are seen):
  4416.  
  4417.                             *CTRL-E*
  4418. CTRL-E            Scroll window [count] lines downwards in the buffer.
  4419.             Mnemonic: Extra lines.
  4420.  
  4421.                             *CTRL-D*
  4422. CTRL-D            Scroll window Downwards in the buffer.  The number of
  4423.             lines comes from the 'scroll' option (default: half a
  4424.             screen).  If [count] given, first set 'scroll' option
  4425.             to [count].  The cursor is moved the same number of
  4426.             lines down in the file (if possible; when lines wrap
  4427.             and when hitting the end of the file there may be a
  4428.             difference).  When the cursor is on the last line of
  4429.             the buffer nothing happens and a beep is produced.
  4430.             See also 'startofline' option.
  4431.             {difference from vi: Vim scrolls 'scroll' screen
  4432.             lines, instead of file lines; makes a difference when
  4433.             lines wrap}
  4434.  
  4435. <S-Down>    or                    *<S-Down>*
  4436. <PageDown>    or                    *<PageDown>* *CTRL-F*
  4437. CTRL-F            Scroll window [count] pages Forwards (downwards) in
  4438.             the buffer.  See also 'startofline' option.
  4439.  
  4440. Move edit window (the part of the buffer that you see) upwards (this means
  4441. that more lines upwards in the text buffer are seen):
  4442.  
  4443.                             *CTRL-Y*
  4444. CTRL-Y            Scroll window [count] lines upwards in the buffer.
  4445.  
  4446.                             *CTRL-U*
  4447. CTRL-U            Scroll window Upwards in the buffer.  The number of
  4448.             lines comes from the 'scroll' option (default: half a
  4449.             screen).  If [count] given, first set the 'scroll'
  4450.             option to [count].  The cursor is moved the same
  4451.             number of lines up in the file (if possible; when
  4452.             lines wrap and when hitting the end of the file there
  4453.             may be a difference).  When the cursor is on the first
  4454.             line of the buffer nothing happens and a beep is
  4455.             produced.  See also 'startofline' option.
  4456.             {difference from vi: Vim scrolls 'scroll' screen
  4457.             lines, instead of file lines; makes a difference when
  4458.             lines wrap}
  4459.  
  4460. <S-Up>        or                    *<S-Up>*
  4461. <PageUp>    or                    *<PageUp>* *CTRL-B*
  4462. CTRL-B            Scroll window [count] pages Backwards (upwards) in the
  4463.             buffer.  See also 'startofline' option.
  4464.  
  4465. Window repositioning:
  4466.  
  4467.                             *z* *z<CR>*
  4468. z<CR>            Redraw, line [count] at top of window (default
  4469.             cursor line).  Put cursor at first non-blank in the
  4470.             line.
  4471.  
  4472.                             *zt*
  4473. zt            Like "z<CR>", but leave the cursor in the same
  4474.             column.  {not in Vi}
  4475.  
  4476.                             *zN<CR>*
  4477. z{height}<CR>        Redraw, make window {height} lines tall.  This is
  4478.             useful to make the number of lines small when screen
  4479.             updating is very slow.  Cannot make the height more
  4480.             than the physical screen height.
  4481.  
  4482.                             *z.*
  4483. z.            Redraw, line [count] at center of window (default
  4484.             cursor line).  Put cursor at first non-blank in the
  4485.             line.
  4486.  
  4487.                             *zz*
  4488. zz            Like "z.", but leave the cursor in the same column.
  4489.             Careful: If caps-lock is on, this commands becomes
  4490.             "ZZ": write buffer and exit!  {not in Vi}
  4491.  
  4492.                             *z-*
  4493. z-            Redraw, line [count] at bottom of window (default
  4494.             cursor line).  Put cursor at first non-blank in the
  4495.             line.
  4496.  
  4497.                             *zb*
  4498. zb            Like "z-", but leave the cursor in the same column.
  4499.             {not in Vi}
  4500.  
  4501. These commands move the contents of the window.  If the cursor position is
  4502. moved off of the window, the cursor is moved onto the window (with
  4503. 'scrolloff' screen lines around it).  A page is the number of lines in the
  4504. window minus two.  The mnemonics for these commands may be a bit confusing.
  4505. Remember that the commands refer to moving the window upwards or downwards
  4506. in the buffer.  When the window moves upwards in the buffer, the text in the
  4507. window moves downwards on your screen.
  4508.  
  4509. z<Right>    or                        *zl* *z<Right>*
  4510. zl            Scroll the screen [count] characters to the left.
  4511.             This only works when 'wrap' is off.  {not in Vi}
  4512.  
  4513. z<Left>      or                        *zh* *z<Left>*
  4514. zh            Scroll the screen [count] characters to the right.
  4515.             This only works when 'wrap' is off.  {not in Vi}
  4516.  
  4517. For these two commands the cursor follows the screen.  If the character that
  4518. the cursor is on is moved off the screen, the cursor is moved to the closest
  4519. character that is on the screen.  The value of 'sidescroll' is not used.
  4520.  
  4521.                             *zs*
  4522. zs            Scroll the screen horizontally to position the cursor
  4523.             at the start (left side) of the screen.  This only
  4524.             works when 'wrap' is off.  {not in Vi}
  4525.  
  4526.                             *ze*
  4527. ze            Scroll the screen horizontally to position the cursor
  4528.             at the end (right side) of the screen.  This only
  4529.             works when 'wrap' is off.  {not in Vi}
  4530.  
  4531. For these two commands the cursor is not moved in the text, only the text
  4532. scrolls on the screen.
  4533.  
  4534.  
  4535. 8. Tags and special searches                *tags_and_searches*
  4536. ============================
  4537.  
  4538. 8.1 Tags                        *tag_commands*
  4539.  
  4540.                             *:ta* *:tag*
  4541. :ta[g][!] {ident}    Jump to the definition of {ident}, using the
  4542.             information in the tags file.  Put {ident} in the tag
  4543.             stack.  See below for [!].
  4544.  
  4545. g<LeftMouse>                        *g<LeftMouse>*
  4546. <C-LeftMouse>                    *<C-LeftMouse>* *CTRL-]*
  4547. CTRL-]            ":ta" to the keyword under or after cursor.  Put the
  4548.             keyword in the tag stack.  {Vi: identifier after the
  4549.             cursor}
  4550.  
  4551.                             *v_CTRL-]*
  4552. {Visual}CTRL-]        ":ta" to the text that is highlighted.  {not in Vi}
  4553.  
  4554. g<RightMouse>                        *g<RightMouse>*
  4555. <C-RightMouse>                    *<C-RightMouse>* *CTRL-T*
  4556. CTRL-T            Jump to [count] older entry in the tag stack
  4557.             (default 1).  {not in Vi}
  4558.  
  4559.                             *:po* *:pop*
  4560. :[count]po[p][!]    Jump to [count] older entry in tag stack (default 1).
  4561.             See below for [!].  {not in Vi}
  4562.  
  4563. :[count]ta[g][!]    Jump to [count] newer entry in tag stack (default 1).
  4564.             See below for [!].  {not in Vi}
  4565.  
  4566.                             *:tags*
  4567. :tags            Show the contents of the tag stack.  The active
  4568.             entry is marked with a '>'.  {not in Vi}
  4569.  
  4570. A tag is an identifier that appears in the "tags" file.  It is a sort of label
  4571. that can be jumped to.  For example: In C programs each function name can be
  4572. used as a tag.
  4573.  
  4574. With the ":tag" command the cursor will be positioned on the tag.  With the
  4575. CTRL-] command, the keyword on which the cursor is standing is used as the
  4576. tag.  If the cursor is not on a keyword, the first keyword to the right of the
  4577. cursor is used.
  4578.  
  4579.                             *tag_priority*
  4580. When there are multiple matches for a tag, this priority is used:
  4581. 1.  The first matching static tag with a full matching tag for the current
  4582.     file.
  4583. 2.  The first matching global tag with a full matching tag.
  4584. 3.  The first matching static tag with a full matching tag for another file.
  4585. 4.  The first matching static tag with an ignore-case matching tag for the
  4586.     current file.
  4587. 5.  The first matching global tag with an ignore-case matching tag.
  4588. 6.  The first matching static tag with an ignore-case matching tag for another
  4589.     file.
  4590.  
  4591.                             *static_tag*
  4592. A static tag is a tag that is defined for a specific file.  In a C program this
  4593. could be a static function.
  4594.  
  4595. In Vi jumping to a tag sets the current search pattern.  This means that
  4596. the "n" command after jumping to a tag does not search for the same pattern
  4597. that it did before jumping to the tag.  Vim does not do this as we consider it
  4598. to be a bug.  You can still find the tag search pattern in the search history.
  4599. If you really want the old Vi behaviour, set the 't' flag in 'cpoptions'.
  4600.  
  4601. If the tag is in the current file this will always work.  Otherwise the
  4602. performed actions depend on whether the current file was changed, whether a !
  4603. is added to the command and on the 'autowrite' option:
  4604.  
  4605.   tag in       file       autowrite
  4606. current file  changed    !   option      action
  4607. -----------------------------------------------------------------------------
  4608.     yes         x    x     x      goto tag
  4609.     no         no    x     x      read other file, goto tag
  4610.     no        yes    yes    x   abandon current file, read other file, goto
  4611.                   tag
  4612.     no        yes    no    on  write current file, read other file, goto
  4613.                   tag
  4614.     no        yes    no   off  fail
  4615. -----------------------------------------------------------------------------
  4616.  
  4617. - If the tag is in the current file, the command will always work.
  4618. - If the tag is in another file and the current file was not changed, the
  4619.   other file will be made the current file and read into the buffer.
  4620. - If the tag is in another file, the current file was changed and a ! is
  4621.   added to the command, the changes to the current file are lost, the other
  4622.   file will be made the current file and read into the buffer.
  4623. - If the tag is in another file, the current file was changed and the
  4624.   'autowrite' option is on, the current file will be written, the other
  4625.   file will be made the current file and read into the buffer.
  4626. - If the tag is in another file, the current file was changed and the
  4627.   'autowrite' option is off, the command will fail.  If you want to save
  4628.   the changes, use the ":w" command and then use ":tag" without an argument.
  4629.   This works because the tag is put on the stack anyway.  If you want to lose
  4630.   the changes you can use the ":tag!" command.
  4631.  
  4632. The ":tag" command works very well for C programs.  If you see a call to a
  4633. function and wonder what that function does, position the cursor inside of
  4634. the function name and hit CTRL-].  This will bring you to the function
  4635. definition.  An easy way back is with the CTRL-T command.  Also read about the
  4636. tag stack below.
  4637.  
  4638. A tags file can be created with the external command 'ctags'.  It will
  4639. contain a tag for each function.  Some versions of 'ctags' will also make a
  4640. tag for each "#defined" macro.
  4641.  
  4642. The lines in the tags file should have this format:
  4643.  
  4644.     {tag}{separator}{filename}{separator}{command}
  4645.  
  4646. {tag}        the identifier
  4647. {separator}    one or more <Tab> or space characters
  4648. {filename}    the file that contains the definition of {tag}
  4649. {command}    the Ex command that positions the cursor on the tag.
  4650.  
  4651. The identifier normally is the name of a function, but it can be any
  4652. identifier.  There is one special form for local (static) functions:
  4653. {filename}:{identifier}.  Some ctags programs make use of this to separate
  4654. local (static) functions from global functions.
  4655. (Detail: Vim compares only the last part of the filename and ignores any
  4656. path before it).
  4657.  
  4658.                             *tag_search*
  4659. The command can be any Ex command, but normally it is a search command like
  4660.     "/^main(argc, argv)"
  4661. If it is a search command, and the search fails, another try is done ignoring
  4662. case.  If that fails too, a search is done for:
  4663.     "^main[ \t]*("
  4664. (the tag with '^' prepended and "[ \t]*(" appended).  When using function
  4665. names, this will find the function name when it is in column 0.  This will
  4666. help when the arguments to the function have changed since the tags file was
  4667. made.  If this search also fails another search is done with:
  4668.     "^[#a-zA-Z_].*main[ \t]*("
  4669. This means: A line starting with '#' or an identifier and containing the tag
  4670. followed by white space and a '('.  This will find macro names and function
  4671. names with a type prepended.  {the extra searches are not in Vi}.
  4672.  
  4673. In Vi the ":tag" command sets the last search pattern when the tag is searched
  4674. for.  In Vim this is not done, the previous search pattern is still remembered,
  4675. unless the 't' flag is present in 'cpoptions'.  The search pattern is always
  4676. put in the search history.
  4677.  
  4678.                             *emacs_tags*
  4679. Emacs style tag files are supported if Vim was compiled with EMACS_TAGS
  4680. defined.  Check the output of ":version", if it contains "+emacs_tags" then it
  4681. was.  Sorry, there is no explanation about Emacs tag files here, it is only
  4682. supported for backwards compatibility :-).
  4683.  
  4684.                             *tags_option*
  4685. The 'tags' option is a list of file names.  Each of these files is searched
  4686. for the tag.  This can be used to use a different tags file than the default
  4687. file "tags".  It can also be used to access a common tags file.
  4688.  
  4689. The next file in the list is not used when:
  4690. - A matching static tag for the current buffer has been found.
  4691. - A matching global tag has been found.
  4692. This also depends on the 'ignorecase' option.  If it is off, and the tags file
  4693. only has a match without matching case, the next tags file is searched for a
  4694. match with matching case.  If no tag with matching case is found, the first
  4695. match without matching case is used.  If 'ignorecase' is on, and a matching
  4696. global tag with or without matching case is found, this one is used, no
  4697. further tags files are searched.
  4698.  
  4699. When a tag file name starts with "./", the '.' is replaced with the path of
  4700. the current file.  This makes it possible to use a tags file in the directory
  4701. where the current file is (no matter what the current directory is).  The idea
  4702. of using "./" is that you can define which tag file is searched first: In the
  4703. current directory ("tags,./tags") or in the directory of the current file
  4704. ("./tags,tags").
  4705.  
  4706. For example:
  4707.  
  4708.     :set tags=./tags,tags,/home/user/commontags
  4709.  
  4710. In this example the tag will first be searched for in the file "tags" in the
  4711. directory where the current file is.  Next the "tags" file in the current
  4712. directory.  If it is not found there, then the file "/home/user/commontags"
  4713. will be searched for the tag.
  4714.  
  4715. Instead of the comma a space may be used.  Then a backslash is required for
  4716. the space to be included in the string option:
  4717.  
  4718.     :set tags=tags\ /home/user/commontags
  4719.  
  4720. To include a space in a file name use three backslashes.  To include a comma in
  4721. a file name use two backslashes.  For example, use:
  4722.  
  4723.     :set tags=tag\\\ file,/home/user/common\\,tags
  4724.  
  4725. for the files "tag file" and "/home/user/common,tags".  The 'tags' option will
  4726. have the value "tag\ file,/home/user/common\,tags".
  4727.  
  4728. If the 'tagrelative' option is on (which is the default) and using a tag file
  4729. in another directory, file names in that tag file are relative to the
  4730. directory where the tag file is.
  4731.  
  4732.  
  4733.                             *tagstack*
  4734. The tags that you use are remembered in the tag stack.  You can print this
  4735. stack with the ":tags" command.  The result looks like this:
  4736.  
  4737.   # TO tag    FROM line in file
  4738.   1 main           1  harddisk2:text/vim/test
  4739. > 2 FuncA          58  -current-
  4740.   3 FuncC         357  harddisk2:text/vim/src/amiga.c
  4741.  
  4742. This list shows the tags that you jumped to and the cursor position before that
  4743. jump.  The older tags are at the top, the newer at the bottom.
  4744.  
  4745. The '>' points to the active entry.  This is the tag that will be used by the
  4746. next ":tag" command.  The CTRL-T and ":pop" command will use the position
  4747. above the active entry.
  4748.  
  4749. The line number and file name are remembered to be able to get back to where
  4750. you were before the tag command.  The line number will be correct, also when
  4751. deleting/inserting lines, unless this was done by another program (e.g.
  4752. another instance of Vim).
  4753.  
  4754. You can jump to previously used tags with several commands.  Some examples:
  4755.  
  4756.     ":pop" or CTRL-T    to position before previous tag
  4757.     {count}CTRL-T        to position before {count} older tag
  4758.     ":tag"            to newer tag
  4759.     ":0tag"            to last used tag
  4760.  
  4761. The most obvious way to use this is while browsing through the call graph of
  4762. a program.  Consider the following call graph:
  4763.  
  4764.     main  --->  FuncA  --->  FuncC
  4765.           --->  FuncB
  4766.  
  4767. (Explanation: main calls FuncA and FuncB; FuncA calls FuncC).
  4768. You can get from main to FuncA by using CTRL-] on the call to FuncA.  Then
  4769. you can CTRL-] to get to FuncC.  If you now want to go back to main you can
  4770. use CTRL-T twice.  Then you can CTRL-] to FuncB.
  4771.  
  4772. If you issue a ":ta {ident}" or CTRL-] command, this tag is inserted at the
  4773. current position in the stack.  If the stack was full (it can hold up to 20
  4774. entries), the oldest entry is deleted and the older entries shift one
  4775. position up (their index number is decremented by one).  If the last used
  4776. entry was not at the bottom, the entries below the last used one are
  4777. deleted.  This means that an old branch in the call graph is lost.  After the
  4778. commands explained above the tag stack will look like this:
  4779.  
  4780.   # TO tag    FROM line in file
  4781.   1 main           1  harddisk2:text/vim/test
  4782.   2 FuncB          59  harddisk2:text/vim/src/main.c
  4783. >
  4784.  
  4785.  
  4786. 8.2 Include file searches                *include_search*
  4787.  
  4788. These commands look for a string in the current file and in all encountered
  4789. included files (recursively).  This can be used to find the definition of a
  4790. variable, function or macro.  If you only want to search in the current
  4791. buffer, use the commands listed at |pattern_searches|.
  4792.  
  4793. When a line is encountered that includes another file, that file is searched
  4794. before continuing in the current buffer.  Files included by included files are
  4795. also searched.  When an include file could not be found it is silently
  4796. ignored.  Use the ":checkpath" command to discover which files could not be
  4797. found, possibly your 'path' option is not set up correctly.  Note: the
  4798. included file is searched, not a buffer that may be editing that file.  Only
  4799. for the current file the lines in the buffer are used.
  4800.  
  4801. The string can be any keyword or a defined macro.  For the keyword any match
  4802. will be found.  For defined macros only lines that match with the 'define'
  4803. option will be found.  The default is "\^#[ \t]*define", which is for C
  4804. programs.  Also, when a match is found for a defined macro, the displaying of
  4805. lines continues with the next line when a line ends in a backslash.
  4806.  
  4807. The commands that start with "[" start searching from the start of the current
  4808. file.  The commands that start with "]" start at the current cursor position.
  4809.  
  4810. The 'include' option is used to define a line that includes another file.  The
  4811. default is "\^#[ \t]*include", which is for C programs.  Note: Vim does not
  4812. recognize C syntax, if the 'include' option matches a line inside
  4813. "#ifdef/#endif" or inside a comment, it is searched anyway.  The 'isfname'
  4814. option is used to recognize the file name that comes after the matched
  4815. pattern.
  4816.  
  4817. The 'path' option is used to find the directory for the include files that
  4818. do not have an absolute path.
  4819.  
  4820. The 'comments' option is used for the commands that display a single line or
  4821. jump to a line.  It defines patterns that may start a comment.  Those lines
  4822. are ignored for the search, unless [!] is used.  One exception: When the line
  4823. matches the pattern "^# *define" it is not considered to be a comment.
  4824.  
  4825.                             *[i*
  4826. [i            Display the first line that contains the keyword
  4827.             under the cursor.  The search starts at the beginning
  4828.             of the file.  Lines that look like a comment are
  4829.             ignored (see 'comments' option).  If a count is given,
  4830.             the count'th matching line is displayed.  {not in Vi}
  4831.  
  4832.                             *]i*
  4833. ]i            like "[i", but start at the current cursor position.
  4834.             {not in Vi}
  4835.  
  4836.                             *:is* *:isearch*
  4837. :[range]is[earch][!] [count] [/]pattern[/]
  4838.             Like "[i"  and "]i", but search in [range] lines
  4839.             (default: whole file).  Without [!] lines that are
  4840.             recognized as comments are skipped.  Without [/] only
  4841.             whole words are matched, using the pattern
  4842.             "\<pattern\>".  {not in Vi}
  4843.  
  4844.                             *[I*
  4845. [I            Display all lines that contain the keyword under the
  4846.             cursor.  File names and line numbers are displayed
  4847.             for the found lines.  The search starts at the
  4848.             beginning of the file.  {not in Vi}
  4849.  
  4850.                             *]I*
  4851. ]I            like "[I", but start at the current cursor position.
  4852.             {not in Vi}
  4853.  
  4854.                             *:il* *:ilist*
  4855. :[range]il[ist][!] [/]pattern[/]
  4856.             Like "[I" and "]I", but search in [range] lines
  4857.             (default: whole file).  Without [!] lines that are
  4858.             recognized as comments are skipped.  Without [/] only
  4859.             whole words are matched, using the pattern
  4860.             "\<pattern\>".  {not in Vi}
  4861.  
  4862.                             *[_CTRL-I*
  4863. [ CTRL-I        Jump to the first line that contains the keyword
  4864.             under the cursor.  The search starts at the beginning
  4865.             of the file.  Lines that look like a comment are
  4866.             ignored (see 'comments' option).  If a count is given,
  4867.             the count'th matching line is jumped to.  {not in Vi}
  4868.  
  4869.                             *]_CTRL-I*
  4870. ] CTRL-I        like "[ CTRL-I", but start at the current cursor
  4871.             position.  {not in Vi}
  4872.  
  4873.                             *:ij* *:ijump*
  4874. :[range]ij[ump][!] [count] [/]pattern[/]
  4875.             Like "[ CTRL-I"  and "] CTRL-I", but search in
  4876.             [range] lines (default: whole file).  Without [!]
  4877.             lines that are recognized as comments are skipped.
  4878.             Without [/] only whole words are matched, using the
  4879.             pattern "\<pattern\>".  {not in Vi}
  4880.  
  4881. CTRL-W CTRL-I                    *CTRL-W_CTRL-I* *CTRL-W_i*
  4882. CTRL-W i        Open a new window, with the cursor on the first line
  4883.             that contains the keyword under the cursor.  The
  4884.             search starts at the beginning of the file.  Lines
  4885.             that look like a comment line are ignored (see
  4886.             'comments' option).  If a count is given, the count'th
  4887.             matching line is jumped to.  {not in Vi}
  4888.  
  4889.                             *:isp* *:isplit*
  4890. :[range]isp[lit][!] [count] [/]pattern[/]
  4891.             Like "CTRL-W i"  and "CTRL-W i", but search in
  4892.             [range] lines (default: whole file).  Without [!]
  4893.             lines that are recognized as comments are skipped.
  4894.             Without [/] only whole words are matched, using the
  4895.             pattern "\<pattern\>".  {not in Vi}
  4896.  
  4897.                             *[d*
  4898. [d            Display the first macro definition that contains the
  4899.             macro under the cursor.  The search starts from the
  4900.             beginning of the file.  If a count is given, the
  4901.             count'th matching line is displayed.  {not in Vi}
  4902.  
  4903.                             *]d*
  4904. ]d            like "[d", but start at the current cursor position.
  4905.             {not in Vi}
  4906.  
  4907.                             *:ds* *:dsearch*
  4908. :[range]ds[earch][!] [count] [/]pattern[/]
  4909.             Like "[d"  and "]d", but search in [range] lines
  4910.             (default: whole file).  Without [!] lines that are
  4911.             recognized as comments are skipped.  Without [/] only
  4912.             whole words are matched, using the pattern
  4913.             "\<pattern\>".  {not in Vi}
  4914.  
  4915.                             *[D*
  4916. [D            Display all macro definitions that contain the macro
  4917.             under the cursor.  File names and line numbers are
  4918.             displayed for the found lines.  The search starts
  4919.             from the beginning of the file.  {not in Vi}
  4920.  
  4921.                             *]D*
  4922. ]D            like "[D", but start at the current cursor position.
  4923.             {not in Vi}
  4924.  
  4925.                             *:dl* *:dlist*
  4926. :[range]dl[ist][!] [/]pattern[/]
  4927.             Like "[D"  and "]D", but search in [range] lines
  4928.             (default: whole file).  Without [!] lines that are
  4929.             recognized as comments are skipped.  Without [/] only
  4930.             whole words are matched, using the pattern
  4931.             "\<pattern\>".  {not in Vi}
  4932.  
  4933.                             *[_CTRL-D*
  4934. [ CTRL-D        Jump to the first macro definition that contains the
  4935.             keyword under the cursor.  The search starts from
  4936.             the beginning of the file.  If a count is given, the
  4937.             count'th matching line is jumped to.  {not in Vi}
  4938.  
  4939.                             *]_CTRL-D*
  4940. ] CTRL-D        like "[ CTRL-D", but start at the current cursor
  4941.             position.  {not in Vi}
  4942.  
  4943.                             *:dj* *:djump*
  4944. :[range]dj[ump][!] [count] [/]pattern[/]
  4945.             Like "[ CTRL-D"  and "] CTRL-D", but search  in
  4946.             [range] lines (default: whole file).  Without [!]
  4947.             lines that are recognized as comments are skipped.
  4948.             Without [/] only whole words are matched, using the
  4949.             pattern "\<pattern\>".  {not in Vi}
  4950.  
  4951. CTRL-W CTRL-D                    *CTRL-W_CTRL-D* *CTRL-W_d*
  4952. CTRL-W d        Open a new window, with the cursor on the first
  4953.             macro definition line that contains the keyword
  4954.             under the cursor.  The search starts from the
  4955.             beginning of the file.  If a count is given, the
  4956.             count'th matching line is jumped to.  {not in Vi}
  4957.  
  4958.                             *:dsp* *:dsplit*
  4959. :[range]dsp[lit][!] [count] [/]pattern[/]
  4960.             Like "CTRL-W d", but search in [range] lines
  4961.             (default: whole file).  Without [!] lines that are
  4962.             recognized as comments are skipped.  Without [/] only
  4963.             whole words are matched, using the pattern
  4964.             "\<pattern\>".  {not in Vi}
  4965.  
  4966.                             *:che* *:checkpath*
  4967. :che[ckpath]        List all the included files that could not be found.
  4968.             {not in Vi}
  4969.  
  4970. :che[ckpath]!        List all the included files.  {not in Vi}
  4971.  
  4972.  
  4973. 9. Inserting text                    *inserting*
  4974. =================
  4975.  
  4976. The following commands can be used to insert new text into the buffer.  They
  4977. can all be undone.  The non-Ex commands can be repeated with the "." command.
  4978.  
  4979.                             *a*
  4980. a            Append text after the cursor [count] times.
  4981.  
  4982.                             *A*
  4983. A            Append text at the end of the line [count] times.
  4984.  
  4985. <Insert>    or                *i* *insert* *<Insert>*
  4986. i            Insert text before the cursor [count] times.
  4987.  
  4988.                             *I*
  4989. I            Insert text before the first CHAR on the line
  4990.             [count] times.
  4991.  
  4992.                             *gI*
  4993. gI            Insert text in column 1 [count] times.  {not in Vi}
  4994.  
  4995.                             *o*
  4996. o            Begin a new line below the cursor and insert text,
  4997.             repeat [count] times.  {Vi: blank [count] screen
  4998.             lines}
  4999.  
  5000.                             *O*
  5001. O            Begin a new line above the cursor and insert text,
  5002.             repeat [count] times.  {Vi: blank [count] screen
  5003.             lines}
  5004.  
  5005. These commands are used to start inserting text.  They can be undone and
  5006. repeated.  You can end Insert mode with <Esc>.  See the section "Insert and
  5007. Replace mode" |mode_ins_repl| for the other special characters in Insert
  5008. mode.  The effect of [count] takes place after Insert mode is exited.
  5009.  
  5010. When 'autoindent' is on, the indent for a new line is obtained from the
  5011. previous line.  When 'smartindent' or 'cindent' is on, the indent for a line
  5012. is automatically adjusted for C programs.
  5013.  
  5014. 'textwidth' can be set to the maximum width for a line.  When a line becomes
  5015. too long when appending characters a line break is automatically inserted.
  5016.  
  5017.                             *:r* *:read*
  5018. :r[ead] [name]        Insert the file [name] (default: current file) below
  5019.             the cursor.
  5020.  
  5021. :{range}r[ead] [name]    Insert the file [name] (default: current file) below
  5022.             the specified line.
  5023.  
  5024.                             *:r!* *:read!*
  5025. :r[ead] !{cmd}        Execute {cmd} and insert its standard output below
  5026.             the cursor.  A temporary file is used to store the
  5027.             output of the command which is then read into the
  5028.             buffer.  'shellredir' is used to save the output of
  5029.             the command, which can be set to include stderr or
  5030.             not.  {cmd} is executed like with ":!{cmd}", any '!'
  5031.             is replaced with the previous command |:!|.
  5032.  
  5033. These commands insert the contents of a file, or the output of a command,
  5034. into the buffer.  They can be undone.  They cannot be repeated with the "."
  5035. command.  They work on a line basis, insertion starts below the line in which
  5036. the cursor is, or below the specified line.  To insert text above the first
  5037. line use the command ":0r {name}".
  5038.  
  5039.                             *textmode_read*
  5040. The <NL> character is recognized as end-of-line marker.  If the 'textmode'
  5041. option is on, a <CR> in front of an <NL> is ignored and a CTRL-Z at the end
  5042. of the file is ignored.  The 'textmode' option is default on for MS-DOS, Win32
  5043. and OS/2.
  5044.  
  5045. If the 'textauto' option is on Vim tries to recognize the type of end-of-line
  5046. marker (see |textmode_io|).  However, the 'textmode' option will not be
  5047. changed.  Only while reading the file the text mode is used or not.
  5048.  
  5049. On non-MS-DOS, Win32, and OS/2 systems the message "[textmode]" is shown if a
  5050. file is read in text mode, to remind you that something unusual is done.  On
  5051. MS-DOS, Win32, and OS/2 the message "[notextmode]" is shown if a file is read
  5052. without text mode.
  5053.  
  5054. An example on how to use ":r !":
  5055.     :r !uuencode binfile binfile
  5056. This command reads "binfile", uuencodes it and reads it into the current
  5057. buffer.  Useful when you are editing e-mail and want to include a binary
  5058. file.
  5059.  
  5060.  
  5061. 10. Deleting text                    *deleting*
  5062. =================
  5063.  
  5064. ["x]<Del>    or                    *<Del>* *x* *dl*
  5065. ["x]x            Delete [count] characters under and after the cursor
  5066.             [into register x] (not linewise).  Does the same as
  5067.             "dl".  See |:fixdel| if the <Del> key does not do what
  5068.             you want.  Also see |'whichwrap'|.  {<Del> not in Vi}
  5069.  
  5070.                             *X* *dh*
  5071. ["x]X            Delete [count] characters before the cursor [into
  5072.             register x] (not linewise).  Does the same as "dh".
  5073.             Also see |'whichwrap'|.
  5074.  
  5075.                             *d*
  5076. ["x]d{motion}        Delete text that is moved over [into register x].
  5077.             See below for exception.
  5078.  
  5079.                             *dd*
  5080. ["x]dd            Delete [count] lines [into register x] (linewise).
  5081.  
  5082.                             *D*
  5083. ["x]D            Delete the characters under the cursor until the end
  5084.             of the line and [count]-1 more lines [into register
  5085.             x]; synonym for d$ (not linewise).
  5086.  
  5087. {Visual}["x]x    or                    *v_x* *v_d*
  5088. {Visual}["x]d        Delete the highlighted text [into register x] (see
  5089.             the chapter on Visual mode |Visual_mode|).  {not in
  5090.             Vi}
  5091.  
  5092. {Visual}["x]X    or                    *v_X* *v_D*
  5093. {Visual}["x]D        Delete the highlighted lines [into register x] (see
  5094.             the chapter on Visual mode |Visual_mode|).  {not in
  5095.             Vi}
  5096.  
  5097.                             *:d* *:delete*
  5098. :[range]d[elete] [x]    Delete [range] lines (default: current line) [into
  5099.             register x].
  5100.  
  5101. :[range]d[elete] [x] {count}
  5102.             Delete {count} lines, starting with [range]
  5103.             (default: current line |cmdline_ranges|) [into
  5104.             register x].
  5105.  
  5106. These commands delete text.  They can be repeated with the "." command
  5107. (except ":d") and undone.  Use Visual mode to delete blocks of text.  See
  5108. |registers| for an explanation of registers.
  5109.  
  5110. An exception for the d{motion} command: If the motion is not linewise, the
  5111. start and end of the motion are not in the same line and before the start
  5112. and after the end are only blanks, the delete becomes linewise.  This means
  5113. that the blank line that would remain is also deleted.
  5114.  
  5115.  
  5116.                             *J*
  5117. J            Join [count] lines, with a minimum of two lines.
  5118.  
  5119.                             *v_J*
  5120. {Visual}J        Join the highlighted lines, with a minimum of two
  5121.             lines.  {not in Vi}
  5122.  
  5123.                             *:j* *:join*
  5124. :[range]j[oin][!]    Join [range] lines.  Same as "J", except when [!] is
  5125.             given, then no spaces will be inserted or deleted.
  5126.             When [range] is given and the start and end of the
  5127.             range are equal, nothing happens.  Default is to join
  5128.             two lines.
  5129.  
  5130. :[range]j[oin][!] {count}
  5131.             Join {count} lines, starting with [range] (default:
  5132.             current line |cmdline_ranges|).  Same as "J", except
  5133.             when [!] is given, then no spaces will be inserted
  5134.             or deleted.
  5135.  
  5136. These commands delete the newline between lines.  This has the effect of
  5137. joining them into one line.  They can be repeated (except ":j") and undone.
  5138.  
  5139. One space is inserted in place of the <NL>, unless the line ended with a
  5140. space, <Tab> or the next line started with a ')'.  If the next line has
  5141. leading white space it is deleted first.  If the 'joinspaces' option is on,
  5142. two spaces are inserted after a period.
  5143.  
  5144.  
  5145. 11. Changing text                    *changing*
  5146. =================
  5147.  
  5148. The following commands can be used to change text, that is delete some text
  5149. and insert something else, with one command.  They can all be undone.  The
  5150. non-Ex commands can be repeated with the "." command.
  5151.  
  5152.  
  5153. 11.1 Delete and insert                    *delete_insert*
  5154.  
  5155.                             *R*
  5156. R            Enter Replace mode: Each character you type replaces
  5157.             an existing character, starting with the character
  5158.             under the cursor.  Repeat the entered text [count]-1
  5159.             times.
  5160.  
  5161.                             *c*
  5162. ["x]c{motion}        Delete {motion} text [into register x] and start
  5163.             insert.
  5164.  
  5165.                             *cc*
  5166. ["x]cc            Delete [count] lines [into register x] and start
  5167.             insert (linewise).  If 'autoindent' is on, preserve
  5168.             the indent of the first line.
  5169.  
  5170.                             *C*
  5171. ["x]C            Delete from the cursor position to the end of the
  5172.             line and [count]-1 more lines [into register x], and
  5173.             start insert.  Synonym for c$ (not linewise).
  5174.  
  5175.                             *s*
  5176. ["x]s            Delete [count] characters [into register x] and start
  5177.             insert (s stands for Substitute).  Synonym for "cl"
  5178.             (not linewise).
  5179.  
  5180.                             *S*
  5181. ["x]S            Delete [count] lines [into register x] and start
  5182.             insert.  Synonym for "cc" (not linewise).
  5183.  
  5184. {Visual}["x]c    or                    *v_c* *v_r*
  5185. {Visual}["x]r        Delete the highlighted text [into register x] and
  5186.             start insert (see the chapter on Visual mode
  5187.             |Visual_mode|).  {not in Vi}
  5188.  
  5189. {Visual}["x]C    or                    *v_C* *v_R*
  5190. {Visual}["x]R        Delete the highlighted lines [into register x] and
  5191.             start insert (see the chapter on Visual mode
  5192.             |Visual_mode|).  {not in Vi}
  5193.  
  5194. Notes:
  5195. - You can end Insert and Replace mode with <Esc>.
  5196. - See the section "Insert and Replace mode" |mode_ins_repl| for the other
  5197.   special characters in these modes.
  5198. - The effect of [count] takes place after Insert or Replace mode is exited.
  5199. - When the 'cpoptions' option contains '$', and the change is within one line,
  5200.   the text is not directly deleted, but a '$' is put at the last deleted
  5201.   character.
  5202.  
  5203. See |registers| for an explanation of registers.
  5204.  
  5205. Replace mode is just like Insert mode, except that for every character you
  5206. enter, one character is deleted.  If the end of a line is reached, further
  5207. characters are appended (just like Insert mode).  In Replace mode the
  5208. backspace key restores the original text (if there was any) (see section
  5209. "Insert and Replace mode" |mode_ins_repl|).
  5210.  
  5211.                         *cw* *cW*
  5212. Special case: "cw" and "cW" are treated like "ce" and "cE" if the cursor is
  5213. on a non-blank.  This is because "cw" is interpreted as change-word, and a
  5214. word does not include the following white space.  {Vi: "cw" when on a blank
  5215. followed by other blanks changes only the first blank; this is probably a
  5216. bug, because "dw" deletes all the blanks}
  5217.  
  5218.  
  5219. 11.2 Simple changes                    *simple_change*
  5220.  
  5221.                             *r*
  5222. r{char}            Replace the character under the cursor with {char}.  If
  5223.             {char} is a <CR> or <NL> the character will be
  5224.             replaced with a line break.  Replacing with a real <CR>
  5225.             can be done by using CTRL-V <CR>.  CTRL-V <NL> will
  5226.             replace with a <Nul>.  {Vi: CTRL-V <CR> still replaces
  5227.             with a line break, cannot replace something with a
  5228.             <CR>}
  5229.             If a [count] is given that many characters will be
  5230.             replaced with [count] {char}s.  When {char} is a <CR>
  5231.             or <NL> only one is inserted.  "5r<CR>" replaces five
  5232.             characters with a single line break;
  5233.             When replacing with a <CR> or <NL> autoindenting is
  5234.             done.  This works just like deleting the characters
  5235.             that are replaced and then doing "i<CR><Esc>".
  5236.  
  5237.                             *~*
  5238. ~            'notildeop' option: switch case of the character
  5239.             under the cursor and move the cursor to the right.
  5240.             If a [count] is given do that many characters {Vi:
  5241.             no count}
  5242.  
  5243. ~{motion}        'tildeop' option: switch case of {motion} text.  {Vi:
  5244.             tilde cannot be used as an operator}
  5245.  
  5246.                             *g~*
  5247. g~{motion}        switch case of {motion} text.  {Not in Vi}
  5248.  
  5249.                             *v_~*
  5250. {Visual}~        switch case of highlighted text (see the chapter on
  5251.             Visual mode |Visual_mode|).  {not in Vi}
  5252.  
  5253.                             *v_U*
  5254. {Visual}U        Make highlighted text uppercase (see the chapter on
  5255.             Visual mode |Visual_mode|).  {not in Vi}
  5256.  
  5257.                             *gU*
  5258. gU{motion}        Make {motion} text uppercase.  {not in Vi}
  5259.  
  5260.                             *v_u*
  5261. {Visual}u        Make highlighted text lowercase (see the chapter on
  5262.             Visual mode |Visual_mode|).  {not in Vi}
  5263.  
  5264.                             *gu*
  5265. gu{motion}        Make {motion} text lowercase.  {not in Vi}
  5266.  
  5267.                             *CTRL-A*
  5268. CTRL-A            Add [count] to the number at or after the cursor.
  5269.             {not in Vi}
  5270.  
  5271.                             *CTRL-X*
  5272. CTRL-X            Subtract [count] from the number at or after the
  5273.             cursor.  {not in Vi}
  5274.  
  5275. The CTRL-A and CTRL-X commands work for (signed) decimal numbers and
  5276. unsigned octal and hexadecimal numbers.  Numbers starting with '0x' or '0X'
  5277. are assumed to be hexadecimal.  To decide whether the hexadecimal number
  5278. should be printed uppercase or not, the case of the rightmost letter in the
  5279. number is considered.  If there is no letter in the current number, the
  5280. previously detected case is used.  Numbers starting with a '0' are considered
  5281. to be octal.  Other numbers are decimal and may be preceded with a minus
  5282. sign.  If the cursor is on a number, that one will be used.  Otherwise the
  5283. number right of the cursor will be used.
  5284.  
  5285. For octal and hexadecimal numbers with leading zeros, the number of
  5286. characters in the number remains equal (when possible).  When doing CTRL-A on
  5287. "0077" it becomes "0100", CTRL-X on "0x0100" becomes "0x00ff".  Note that
  5288. when there are no leading zeros this does not work, so CTRL-X on "0x100"
  5289. results in "0xff".  Note that decimal numbers with leading zeros are
  5290. impossible, because they are recognized as octal numbers.
  5291.  
  5292. The CTRL-A command is very useful in a macro.  Example: How to make a
  5293. numbered list.
  5294.  
  5295. 1. Create the first entry.  The entry should start with a number.
  5296. 2. qa         - start recording into buffer 'a'
  5297. 3. Y         - yank the entry
  5298. 4. p         - put a copy of the entry below the first one
  5299. 5. CTRL-A    - increment the number
  5300. 6. q         - stop recording
  5301. 7. <count>@a - repeat the yank, put and increment <count> times
  5302.  
  5303.                             *<*
  5304. <{motion}        Shift the {motion} lines one 'shiftwidth' leftwards.
  5305.  
  5306.                             *<<*
  5307. <<            Shift [count] lines one 'shiftwidth' leftwards.
  5308.  
  5309.                             *v_<*
  5310. {Visual}[count]<    Shift the highlighted lines [count] 'shiftwidth'
  5311.             leftwards (see the chapter on Visual mode
  5312.             |Visual_mode|).  {not in Vi}
  5313.  
  5314.                             *>*
  5315. >{motion}        Shift {motion} lines one 'shiftwidth' rightwards.
  5316.  
  5317.                             *>>*
  5318. >>            Shift [count] lines one 'shiftwidth' rightwards.
  5319.  
  5320.                             *v_>*
  5321. {Visual}[count]>    Shift the highlighted lines [count] 'shiftwidth'
  5322.             rightwards (see the chapter on Visual mode
  5323.             |Visual_mode|).  {not in Vi}
  5324.  
  5325.                             *:<*
  5326. :[range]<        Shift [range] lines one 'shiftwidth' left.  Repeat '<'
  5327.             for shifting multiple 'shiftwidth's.
  5328.  
  5329. :[range]< {count}    Shift {count} lines one 'shiftwidth' left, starting
  5330.             with [range] (default current line |cmdline_ranges|).
  5331.             Repeat '<' for shifting multiple 'shiftwidth's.
  5332.  
  5333. :[range]le[ft] [indent]    left align lines in [range].  Sets the indent in the
  5334.             lines to [indent] (default 0).  {not in Vi}
  5335.  
  5336.                             *:>*
  5337. :[range]>        Shift {count} [range] lines one 'shiftwidth' right.
  5338.             Repeat '>' for shifting multiple 'shiftwidth's.
  5339.  
  5340. :[range]> {count}    Shift {count} lines one 'shiftwidth' right, starting
  5341.             with [range] (default current line |cmdline_ranges|).
  5342.             Repeat '>' for shifting multiple 'shiftwidth's.
  5343.  
  5344. The ">" and "<" commands are handy for changing the indent within programs.
  5345. The size of the white space which is inserted or deleted can be set with the
  5346. 'shiftwidth' option.  Normally the 'shiftwidth' option is 8, but you can set it
  5347. to, say, 3 to make smaller indents.  The shift leftwards stops when there is no
  5348. indent.  The shift right does not do anything with empty lines.
  5349.  
  5350. If the 'shiftround' option is on, the indent is rounded to a multiple of
  5351. 'shiftwidth'.
  5352.  
  5353. If the 'smartindent' option is on, or 'cindent' is on and 'cinkeys' contains
  5354. '#', lines starting with '#' will not be shifted right (they are supposed to
  5355. be C preprocessor lines that must stay in column 1).
  5356.  
  5357. When the 'expandtab' option is off (this is the default) <Tab>s are used as
  5358. much as possible to make the indent.  You can use ">><<" to replace an indent
  5359. made out of spaces with the same indent made out of <Tab>s (and a few
  5360. spaces if necessary).  If the 'expandtab' option is on, only spaces are
  5361. used.  Then you can use ">><<" to replace <Tab>s in the indent by spaces (or
  5362. use ":retab!").
  5363.  
  5364. To move a line several 'shiftwidth's use the Visual mode or the ":"
  5365. commands.  For example:
  5366.     Vjj4>        move three lines 4 indents to the right
  5367.     :<<<        move current line 3 indents to the left
  5368.     :>> 5        move 5 lines 2 indents to the right
  5369.     :5>>        move line 5 2 indents to the right
  5370.  
  5371.  
  5372. 11.3 Complex changes                    *complex_change*
  5373.  
  5374.                             *!*
  5375. !{motion}{filter}    Filter {motion} text through the external program
  5376.             {filter}.
  5377.  
  5378.                             *!!*
  5379. !!{filter}        Filter [count] lines through the external program
  5380.             {filter}.
  5381.  
  5382.                             *v_!*
  5383. {Visual}!{filter}    Filter the highlighted lines through the external
  5384.             program {filter} (see the chapter on Visual mode
  5385.             |Visual_mode|).  {not in Vi}
  5386.  
  5387. :{range}![!]{filter} [!][arg]                *:range!*
  5388.             Filter {range} lines through the external program
  5389.             {filter}.  The optional bangs are replaced with the
  5390.             latest given command.  The optional [arg] is
  5391.             appended.  The output of the filter command is
  5392.             temporaryly saved in a file and then read into the
  5393.             buffer.  The 'shellredir' option is used to write the
  5394.             output of the filter in the temporary file.
  5395.  
  5396.                             *=*
  5397. ={motion}        Filter {motion} lines through the external program
  5398.             given with the 'equalprg' option.  When the 'equalprg'
  5399.             option is empty (this is the default), use the
  5400.             internal formatting function to set the indent of each
  5401.             line |C_indenting|.
  5402.  
  5403.                             *==*
  5404. ==            Filter [count] lines through the external program
  5405.             given with the 'equalprg' option.  When the 'equalprg'
  5406.             option is empty (this is the default), use the
  5407.             internal formatting function |C_indenting|.
  5408.  
  5409.                             *v_=*
  5410. {Visual}=        Filter the highlighted lines through the external
  5411.             program given with the 'equalprg' option.  When the
  5412.             'equalprg' option is empty (this is the default),
  5413.             use the internal formatting function |C_indenting|.
  5414.             (see the chapter on Visual mode |Visual_mode|).  {not
  5415.             in Vi}
  5416.  
  5417. A filter is a program that accepts text at standard input, changes it in some
  5418. way, and sends it to standard output.  The commands above can be used to send
  5419. some text through a filter.  An example of a filter is "sort", which sorts
  5420. lines alphabetically.  The "indent" program is used to pretty indent C programs
  5421. (you need a version of indent that works like a filter, not all versions do
  5422. that).  The shell, given with the 'shell' option, is used to execute the
  5423. command (See also the 'shelltype' option).  The filter commands can be redone
  5424. with ".".  There cannot be a comment (with '"') after the ":!" command.
  5425.  
  5426.  
  5427.                         *:s* *:substitute*
  5428. :[range]s[ubstitute]/{pattern}/{string}/[g][c][r][p] [count]
  5429.             For each line in [range] replace {pattern} with
  5430.             {string}.  See below for the flags.
  5431.  
  5432. :[range]s[ubstitute] [g][c][r] [count]
  5433. :[range]&[g][c][r] [count]            *:&*
  5434.             Repeat last :substitute with same search pattern and
  5435.             substitute string.  The flags may be different (see
  5436.             below).
  5437.  
  5438. :[range]~[g][c][r] [count]            *:~*
  5439.             Repeat last substitute with same substitute string
  5440.             but with last used search pattern.  This is like
  5441.             "&r".  See explanation for [r] below.
  5442.  
  5443.                         *&*
  5444. &            Synonym for ":s//~/" (repeat last substitute).
  5445.  
  5446. The arguments that can be given to the substitute commands:
  5447. [g]    All occurrences in the line are replaced.  Otherwise only the first
  5448.     occurrence in the line is replaced.  If the 'edcompatible' option is
  5449.     on this flag is remembered and toggled each time it is used.  It is
  5450.     reset when a new search pattern is given.  If the 'gdefault' option
  5451.     is on, this flag is default on, give the [g] to switch it off.
  5452. [c]    Each substitute has to be confirmed.  The cursor is positioned on the
  5453.     matching string.  You can type:                *:s_c*
  5454.         'y'        to substitute this match
  5455.         'n'        to skip this match
  5456.         <Esc>   to skip this match
  5457.         'a'        to substitute this and all remaining matches {not in Vi}
  5458.         'q'        to quit substituting {not in Vi}
  5459.         CTRL-E  to scroll the screen up {not in Vi}
  5460.         CTRL-Y  to scroll the screen down {not in Vi}.
  5461.     If the 'edcompatible' option is on the [c] flag is remembered and
  5462.     toggled each time it is used.  It is reset when a new search pattern
  5463.     is given.
  5464. [r]    When the search pattern is empty use the previously used search
  5465.     pattern instead of the search pattern from the last substitute or
  5466.     ":global".  If the last command that did a search was a substitute or
  5467.     ":global" there is no effect.  If the last command was a search
  5468.     command, like "/", the pattern from that command is used.
  5469. [p]    Print the line containing the last substitute.
  5470. [count] That many lines are are searched, starting with the last line number
  5471.     in [range] (default current line |cmdline_ranges|).
  5472.  
  5473. If the {pattern} for the substitute command is empty, the pattern from the
  5474. last substitute or ":global" command is used.  With the [r] flag the pattern
  5475. from the last substitute, ":global" or search command is used.
  5476.  
  5477. For compatibility with Vi these two execptions are allowed:
  5478. "\/{string}/" and "\?{string}?" do the same as "//{string}/r".
  5479. "\&{string}&" does the same as "//{string}/".
  5480.  
  5481. Instead of the '/' which surrounds the pattern and replacement string, you
  5482. can use any other character, but not an alphanumeric character, '"' or '|'
  5483. or '#'.  This is useful if you want to include a '/' in the search pattern or
  5484. replacement string.  Example: ":s+/+//+"
  5485.  
  5486. For the definition of a pattern see 6.6, "Pattern searches" |search_pattern|.
  5487.  
  5488. Some characters in {string} have a special meaning:
  5489.  
  5490. magic    nomagic      action
  5491.   &      \&      replaced with the whole matched pattern
  5492.  \&       &      replaced with &
  5493.       \0      replaced with the whole matched pattern
  5494.       \1      replaced with the matched pattern in the first pair of ()
  5495.       \2      replaced with the matched pattern in the second pair of ()
  5496.       ..      ..
  5497.       \9      replaced with the matched pattern in the ninth pair of ()
  5498.   ~      \~      replaced with the {string} of the previous substitute
  5499.  \~       ~      replaced with ~
  5500.       \u      next character made uppercase
  5501.       \U      following characters made uppercase
  5502.       \l      next character made lowercase
  5503.       \L      following characters made lowercase
  5504.       \e      end of /u, /U, /l and /L
  5505.       \E      end of /u, /U, /l and /L
  5506.       <CR>      split line in two at this point
  5507.       \r      idem
  5508.       \n      <NL>
  5509.       \b      <BS>
  5510.       \t      <Tab>
  5511.   CTRL-V <CR>      insert a carriage-return (CTRL-M)
  5512.  
  5513. Examples:
  5514. :s/a\|b/xxx\0xxx/g          modifies "a b"      in "xxxaxxx xxxbxxx"
  5515. :s/\([abc]\)\([efg]\)/\2\1/g  modifies "af fa bg" in "fa fa gb"
  5516. :s/abcde/abc^Mde/          modifies "abcde"      in "abc", "de" (two lines)
  5517. :s/$/^V^M/              modifies "abcde"      in "abcde^M"
  5518.  
  5519. Note: To insert a ^M you have to type CTRL-V <CR>.  To insert a ^V you have
  5520. to type CTRL-V CTRL-V.  So to insert the ^V^M in the last example you have to
  5521. type CTRL-V CTRL-V CTRL-V <CR>.
  5522.  
  5523. Because CTRL-V <CR> inserts a <CR>, it is impossible to insert a CTRL-V just
  5524. in front of a line break.  You will have to split it up in two parts:
  5525.     :s/foo/^Vxxxx/
  5526.     :s/xxxx/^M/
  5527.  
  5528. When using parentheses in combination with '|', like in \([ab]\)\|\([cd]\),
  5529. either the first or second pattern in parentheses did not match, so either
  5530. \1 or \2 is empty.  Example:
  5531. :s/\([ab]\)\|\([cd]\)/\1x/g   modifies "a b c d"  in "ax bx x x"
  5532.  
  5533.                             *:ret* *:retab*
  5534. :[range]ret[ab][!] [new_tabstop]
  5535.             All sequences of white-space containing a tab are
  5536.             replaced with new strings of white-space using the new
  5537.             tabstop value given.  If no new tabstop size is
  5538.             given, the current value of 'tabstop' is used.  With
  5539.             !, strings of normal spaces will also be replace with
  5540.             tabs where appropriate.  With 'expandtab' on, all
  5541.             tabs will be replaced with the appropriate number of
  5542.             spaces.  This command sets 'tabstop' to the new
  5543.             value given, and if performed on the whole file,
  5544.             which is default, should not make any visible
  5545.             change.  Careful: In a C program a <Tab> inside a
  5546.             string will also be affected.  Use "\t" to avoid this
  5547.             (that's a good habit anyway).  {not in Vi}
  5548.  
  5549.  
  5550. 11.4 Formatting text                        *formatting*
  5551.  
  5552. :[range]ce[nter] [width]                *:ce* *:center*
  5553.             Center lines in [range] between [width] columns
  5554.             (default 'textwidth' or 80 when 'textwidth' is 0).
  5555.             {not in Vi}
  5556.  
  5557. :[range]ri[ght] [width]                    *:ri* *:right*
  5558.             right align lines in [range] at [width] columns
  5559.             (default 'textwidth' or 80 when 'textwidth' is 0).
  5560.             {not in Vi}
  5561.  
  5562.                             *:le* *:left*
  5563. :[range]le[ft] [indent]    left align lines in [range].  Sets the indent in the
  5564.             lines to [indent] (default 0).  {not in Vi}
  5565.  
  5566. gq{motion}                        *Q* *gq*
  5567. Q{motion}        Format the lines that were moved over.  The length of
  5568.             each line will be restricted to the width given with
  5569.             the 'textwidth' option.  See below.  If the
  5570.             'textwidth' option is 0, the width of the screen is
  5571.             used (with a maximum of 79).  {not in Vi}
  5572.             NOTE: The "Q" command is used in Vi to go to Ex mode.
  5573.             In a future version of Vim this will be made
  5574.             compatible.  Use "gq" for formatting now, to avoid
  5575.             problems when upgrading to a newer version of Vim.
  5576.  
  5577. {Visual}gq                            *v_Q* *v_gq*
  5578. {Visual}Q        Format the highlighted text.  (see the chapter on
  5579.             Visual mode |Visual_mode|).  {not in Vi}
  5580.  
  5581. Example: To format the current paragraph use "gqp".
  5582.  
  5583. After the "gq" command the cursor is left in the line where the motion command
  5584. would take the cursor.  This allows for the formatting to be repeated with
  5585. ".".  This works fine with "gqj" (format current and next line) and "gq}"
  5586. (format until end of paragraph).  Note: When 'formatprg' is set, the cursor is
  5587. left on the first formatted line (like when using a filter command).
  5588.  
  5589. If the 'autoindent' option is on, the indent of the first line is used for
  5590. the following lines.
  5591.  
  5592. Empty lines are left unchanged (but lines with spaces or tabs are!).
  5593.  
  5594. The 'formatprg' option can be set to the name of an external program, which
  5595. will be used instead of the internal function.  The 'textwidth' and other
  5596. options will not be used then.
  5597.  
  5598.                             *format_comments*
  5599. Comments can be formatted in a special way.  A comment is recognized by a
  5600. specific string at the start of the line (ignoring white space).  Three types
  5601. of comments can be used:
  5602.  
  5603. - Repeating the comment string at the start of each line.  An example is the
  5604.   type of comment used in shell scripts, starting with "#".
  5605. - Only the first line has the comment string, following lines don't.  An
  5606.   example is this list with dashes.
  5607. - Three-piece comments, that have a start string, an end string and optional
  5608.   lines in between.  The strings for the start, middle and end are different.
  5609.   An example is the C-style comment:
  5610.       /*
  5611.      *  this is a C comment
  5612.      */
  5613.  
  5614. The 'comments' option can be set to a comma separated list of parts.  Each
  5615. part defines a type of comment that is recognized.  A part consists of:
  5616.     {flags}:{string}
  5617.  
  5618. {string} is the literal text that must appear.
  5619.  
  5620. {flags}:
  5621.   n    Nested comment.  Nesting with mixed parts is allowed.  If 'comments'
  5622.     is "n:),n:>" a line starting with "> ) >" is accepted as comment.
  5623.  
  5624.   b    Blank (<Space>, <Tab> or end-of-line) required after {string}.
  5625.  
  5626.   f    First line has comment only, will not be repeated on next line, but
  5627.     indent is kept (for bullet-lists).
  5628.   s    Start of three-piece comment
  5629.   m    Middle of a three-piece comment
  5630.   e    End of a three-piece comment
  5631.  
  5632.   l    Left adjust middle with start or end (default).  Only recognized when
  5633.       used together with 's' or 'e'.
  5634.   r    Right adjust middle with start or end.  Only recognized when used
  5635.       together with 's' or 'e'.
  5636.  
  5637. When neither 'f', 's', 'm' or 'e' is given, a repeated comment string is
  5638. assumed.  It is possible to have an empty flags field.
  5639.  
  5640. Blank space in the text before and after the {string} is also included.  The
  5641. {string} in the 'comments' option should not include leading or trailing
  5642. blanks (although it is allowed, in which case they are required).
  5643.  
  5644. When one comment leader is part of another, put it after that one.  For
  5645. example, to include both "-" and "->", use
  5646.     :set comments=f:->,f:-
  5647.  
  5648. A three-piece comment must always be given as start-middle-end, with no other
  5649. parts in between.  An example of a three-piece comment is "sr:/*,mb:*,el:*/" for
  5650. C-comments.  To avoid recognizing "*ptr" the 'b' flag is included for the
  5651. middle.  For three-piece comments the text after the start and middle is
  5652. checked for the appearance of the end.  If it is, the comment will not
  5653. continue below.  The middle part must be present, because otherwise Vim can't
  5654. recognize the middle lines.
  5655.  
  5656. Examples:
  5657. "b:*"    Includes lines starting with "*", but not if the "*" is followed by a
  5658.     non-blank.  This avoids a pointer dereference like "*str" to be
  5659.     recognized as a comment.
  5660. "n:>"    Includes a line starting with ">", ">>", ">>>", etc.
  5661. "fb:-"    Format a list that starts with "- ".
  5662.  
  5663. By default, "b:#" is included.  This means that a line that starts with
  5664. "#include" is not recognized as a comment line.  But a line that starts with
  5665. "# define" is recognized.  In C code this is good, because somewhere after this
  5666. a "#endif" is needed.
  5667.  
  5668.                             *fo_table*
  5669. The 'formatoptions' option can be set to influence the way how comments are
  5670. formatted.  It is a string option, that may contain any of these letters.  The
  5671. default is "tcq".  Commas can be added for readability.
  5672.  
  5673. letter     meaning when present in 'formatoptions'
  5674.  
  5675. t    Do text autowrapping using textwidth
  5676. c    Do comment autowrapping using textwidth, inserting the current
  5677.     comment leader automatically.
  5678. r    Automatically insert the current comment leader after hitting
  5679.     <return> in insert mode.
  5680. o    Automatically insert the current comment leader after hitting 'o' or
  5681.     'O' in Normal mode.
  5682. q    Allow formatting of comments with "gq" (or "Q", which is obsolete).
  5683.     Note that blank lines, or lines containing only the comment leader
  5684.     will be left untouched.  A new paragraph starts after such a line, or
  5685.     when the comment leader changes.
  5686. 2    When formatting text the indent of the second line of a paragraph is
  5687.     used for the rest of the paragraph.  This allows for paragraphs with
  5688.     a different indent for the first line.
  5689. v    Vi-compatible auto wrapping in insert mode: Only break a line at a
  5690.     blank that has been entered during the current insert command.  (Note:
  5691.     this is not 100% Vi compatible, Vi has some "unexpected features" or
  5692.     bugs in this area.  It uses the screen column instead of the line
  5693.     column)
  5694. b    Like 'v', but only auto wrap if a blank has been entered at or before
  5695.     the wrap margin.  If the line was longer than 'textwidth' when the
  5696.     insert started, or no blank was entered in the current insert before
  5697.     reaching 'textwidth', there is no auto wrapping.
  5698. l    Long lines are not broken in insert mode: When a line was longer than
  5699.     'textwidth' when the insert command started it is not automatically
  5700.     formatted.
  5701.  
  5702. With 't' and 'c' you can decide when auto-wrapping is done:
  5703. value    action
  5704. ""    no automatic formatting, "gq" can be used for manual formatting
  5705. "t"    automatic formatting of text, not for comments
  5706. "c"    automatic formatting for comments, not for text (good for C code)
  5707. "tc"    automatic formatting for text and comments
  5708.  
  5709. Note that when 'textwidth' is 0, no formatting is done anyway (but the comment
  5710. leader is inserted).
  5711. Note that when 'paste' is on, no formatting is done at all.
  5712. Note that 'textwidth' can be non-zero even though auto-wrapping never occurs.
  5713. This is good because it can be used for formatting only in this case (with
  5714. "gq").
  5715.  
  5716. If "/*", "*" and/or "*/" are in the 'comments' variable, then Vim has some
  5717. built in stuff to treat these types of comments a bit more cleverly.
  5718. Opening a new line before or after "/*" or "*/" (with 'r' or 'o' present in
  5719. 'formatoptions') gives the correct start of the line automatically.  The same
  5720. happens with formatting and auto-wrapping. Opening a line after a line
  5721. starting with "/*" or "*" and containing "*/", will cause no comment leader to
  5722. be inserted, and the indent of the new line is taken from the line containing
  5723. the start of the comment.
  5724. E.g.:
  5725.     /*
  5726.      * Your typical comment.
  5727.      */
  5728.     The indent on this line is the same as the start of the above
  5729.     comment.
  5730.  
  5731. All this should be really cool, especially in conjunction with the new
  5732. :autocmd command to prepare different settings for different types of file.
  5733.  
  5734. Some examples:
  5735.   for C code:        fo="croq"    (only format comments)
  5736.   for Mail/news:    fo="tcrq"    (format all, don't start comment with "o"
  5737.                   command)
  5738.  
  5739.  
  5740. 11.5 Indenting C programs                *C_indenting*
  5741.  
  5742. C programs can be automatically indented.  Only the indent is set, no other
  5743. formatting is done.  To format comments see |format_comments|.
  5744.  
  5745. There are in fact three methods that can be used.
  5746. 'autoindent'    Just takes the indent from the previous line.
  5747. 'smartindent'    Is like 'autoindent' but also recognizes some C syntax to
  5748.         increase/reduce the indent where appropriate.
  5749. 'cindent'    Works more clever than the other two and can be configured to
  5750.         different indenting styles.
  5751. The rest of this section is about the 'cindent' option.
  5752.  
  5753. Note that the indenting done with 'cindent' does not work for 100%.  Vim is
  5754. not a C compiler, not all syntax is recognized.
  5755.  
  5756. Four options are used for C program indenting:
  5757. 'cindent'    When on automatic C program indenting is enabled.
  5758. 'cinkeys'    Keys that trigger reindenting in insert mode.
  5759. 'cinoptions'    For setting your preferred indent style.
  5760. 'cinwords'    Defines keywords that start an extra indent in the next line.
  5761.  
  5762. If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using
  5763. this algorithm rather than calling an external program.
  5764.  
  5765. See |autocommand| for how to automatically set the 'cindent' option for C code
  5766. files and reset it for others.
  5767.  
  5768.                             *'cinkeys'* *'cink'*
  5769. The 'cinkeys' option can be set to a string that says when to do indenting.
  5770. The default is "0{,0},:,0#,!^F,o,O,e".  This means that indenting is done
  5771. when:
  5772.     "0{"    typing '{' as the first character in a line
  5773.     "0}"    typing '}' as the first character in a line
  5774.     ":"    typing ':' anywhere
  5775.     "0#"    typing '#' as the first character in a line
  5776.     "!^F"    typing CTRL-F, which is not inserted
  5777.     "o"    typing a <CR> anywhere and for the "o" command (not in insert
  5778.         mode!)
  5779.     "O"    for the "O" command (not in insert mode!)
  5780.     "e"    typing the second 'e' for an "else" at the start of a line
  5781.  
  5782. Characters that can be prepended:
  5783. '!'    When the key is preceded with a '!' the key will not be inserted but
  5784.     will just cause the current line to be reindented.  This allows you to
  5785.     set a command key for reindenting the current line.  By default CTRL-F
  5786.     is used for this.  Careful with CTRL-I, you might think that it is a
  5787.     nice command for Indenting, but it is the same as a <Tab>.
  5788. '*'    When the key is preceded with a '*' the reindenting will be done
  5789.     before inserting the key.  If you use "*<Return>" this means that the
  5790.     current line will be reindented, before opening a new line.
  5791.  
  5792. When the key is not preceded with a '!' or '*' the reindenting will be done
  5793. after inserting the key.  So ';' will set the indentation of the line
  5794. including the ';'.
  5795.  
  5796. '0'    When a zero is used before the key (but after '!' or '*') it will only
  5797.     trigger reindenting if the key is the first character typed in the
  5798.     line.
  5799.  
  5800. Special key names:
  5801. <>    Angle brackets mean spelled-out names of keys.  For example: "<Up>",
  5802.     "<Ins>".
  5803. '^'    Letters preceded by a caret (^) are control characters.  For example:
  5804.     "^F" is CTRL-F.
  5805. 'o'    Means to reindent a line for the "o" command and whenever a new
  5806.     line is opened below the current one.  This includes hitting <Return>
  5807.     in insert mode.
  5808. 'O'    Means to reindent a line for the "O" command.
  5809. 'e'    Means to reindent a line that starts with "else" when an 'e' is
  5810.     inserted.
  5811.  
  5812. If you really want to reindent when you type 'o', 'O', 'e', '0', '<', '>', '*'
  5813. or '!', use "<o>", "<O>", "<e>", "<0>", "<<>", "<>>", "<*>" or "<!>",
  5814. respectively, for those keys.
  5815.  
  5816. For an emacs-style indent mode, where lines aren't indented every time you
  5817. press Return but only if you press Tab, I suggest:
  5818.     :set cinkeys=0{,0},:,0#,!<Tab>,!^F
  5819.  
  5820. Note: When the indent of the current line was changed manually, cindenting
  5821. won't be done for any key.  This is to avoid re-indenting after you changed
  5822. the indent by typing <BS>, <Tab> or <Space> in the indent, or used CTRL-T or
  5823. CTRL-D.
  5824.  
  5825. How the indenting is done can be set with 'cinoptions'.  In the list below,
  5826. "N" represents a number of your choice.  It can be negative.  When there is an
  5827. 's' after the number, it is multiplied with 'shiftwidth'.  "1s" is
  5828. 'shiftwidth', "2s" is two times 'shiftwidth', etc.  A decimal point is allowed
  5829. too: "-0.5s" is minus half a 'shiftwidth'.  The examples given below assume a
  5830. 'shiftwidth' of 4.
  5831.  
  5832.     >N    Amount added for "normal" indent.  Used after a line that should
  5833.           increase the indent (lines starting with "if", an opening brace,
  5834.           etc.).  (default 'shiftwidth').
  5835.  
  5836.             cino=               cino=>2             cino=>2s
  5837.           if (cond)           if (cond)           if (cond)
  5838.           {                   {                   {
  5839.               foo;              foo;                      foo;
  5840.           }                   }                   }
  5841.  
  5842.     eN    Add N to the prevailing indent inside a set of braces if the
  5843.           opening brace at the End of the line (more precise: is not the
  5844.           first character in a line).  This is useful if you want a
  5845.           different indent when the '{' is at the start of the line from
  5846.           when '{' is at the end of the line.  (default 0).
  5847.  
  5848.             cino=               cino=e2             cino=e-2
  5849.               if (cond) {         if (cond) {         if (cond) {
  5850.                   foo;                  foo;            foo;
  5851.               }                   }                   }
  5852.               else                else                else
  5853.               {                   {                   {
  5854.                   bar;                bar;                bar;
  5855.               }                   }                   }
  5856.  
  5857.     nN    Add N to the prevailing indent for a statement after an "if",
  5858.           "while", etc., if it is Not inside a set of braces.  This is
  5859.           useful if you want a different indent when there is no '{'
  5860.           before the statement from when there is a '{' before it.
  5861.           (default 0).
  5862.  
  5863.             cino=               cino=n2             cino=n-2
  5864.               if (cond)           if (cond)           if (cond)
  5865.                   foo;                  foo;            foo;
  5866.               else                else                else
  5867.               {                   {                   {
  5868.                   bar;                bar;                bar;
  5869.               }                   }                   }
  5870.  
  5871.     fN    The First opening brace of a function or other block is placed
  5872.           in column N.  Only for an opening brace that is not inside other
  5873.           braces and is at the start of the line.  What comes after the
  5874.           brace is put relative to this brace.  (default 0).
  5875.  
  5876.             cino=               cino=f.5s           cino=f1s
  5877.           func()              func()              func()
  5878.           {                     {                     {
  5879.               int foo;              int foo;              int foo;
  5880.  
  5881.     {N    Opening braces are placed N characters from the prevailing
  5882.           indent.  Only for opening braces that are inside
  5883.           other braces.  (default 0).
  5884.  
  5885.             cino=               cino={.5s           cino={1s
  5886.           if (cond)           if (cond)           if (cond)
  5887.           {                     {                     {
  5888.               foo;                foo;                foo;
  5889.  
  5890.     }N    Closing braces are placed N characters from the matching opening
  5891.           brace.  (default 0).
  5892.  
  5893.             cino=               cino={2,}-0.5s      cino=}2
  5894.           if (cond)           if (cond)           if (cond)
  5895.           {                     {                 {
  5896.               foo;                foo;                foo;
  5897.           }                   }                     }
  5898.  
  5899.     ^N    Add N to the prevailing indent inside a set of braces if the
  5900.           opening brace is in column 0.  This is used to have a different
  5901.           indent for whole of a function (some may like to set it to a
  5902.           negative number).  (default 0).
  5903.  
  5904.         cino=               cino=^-2            cino=^-s
  5905.           func()              func()              func()
  5906.           {                   {                   {
  5907.               if (cond)         if (cond)         if (cond)
  5908.               {                {                 {
  5909.               a = b;            a = b;            a = b;
  5910.               }                }                 }
  5911.           }                   }                   }
  5912.  
  5913.     :N    Case labels are placed N characters from the indent of the
  5914.           switch().  (default 'shiftwidth').
  5915.  
  5916.             cino=               cino=:0
  5917.           switch (x)          switch(x)
  5918.           {              {
  5919.               case 1:         case 1:
  5920.                   a = b;          a = b;
  5921.               default:          default:
  5922.           }              }
  5923.  
  5924.     =N    Statements after a case label are placed N characters from the
  5925.           indent of the label.  (default 'shiftwidth').
  5926.  
  5927.             cino=               cino==10
  5928.            case 11:        case 11:  a = a + 1;
  5929.                a = a + 1;                 b = b + 1;
  5930.  
  5931.     pN    Parameter declarations for K&R-style function declarations will
  5932.           be indented N characters from the margin.  (default
  5933.           'shiftwidth').
  5934.  
  5935.             cino=               cino=p0             cino=p2s
  5936.           func(a, b)          func(a, b)          func(a, b)
  5937.               int a;          int a;                      int a;
  5938.               char b;         char b;                     char b;
  5939.  
  5940.     tN    Type for a function declaration will be indented N characters
  5941.           from the margin.  (default 'shiftwidth').
  5942.  
  5943.             cino=               cino=t0             cino=t7
  5944.               int             int                        int
  5945.           func()              func()              func()
  5946.  
  5947.     +N    Continuation lines (lines that spill onto two) are indented N
  5948.           additional characters.  (default 'shiftwidth').
  5949.  
  5950.             cino=                     cino=+10
  5951.           a = b + 9 *               a = b + 9 *
  5952.               c;                              c;
  5953.  
  5954.     cN    Comment lines after the comment opener, when there is no other
  5955.           text to line up with, are indented N characters from the comment
  5956.           opener.  (default 3).  See also |format_comments|.
  5957.  
  5958.             cino=                     cino=c5
  5959.           /*                        /*
  5960.              text.                       text.
  5961.            */                 */
  5962.  
  5963.     (N    When in unclosed parentheses, indent N characters from the line
  5964.           with the unclosed parentheses.  When N is 0 or the line starts
  5965.           with '(' line up with the unclosed parentheses.  (default
  5966.           'shiftwidth' * 2).
  5967.  
  5968.             cino=                     cino=(0
  5969.           if (c1 && (c2 ||          if (c1 && (c2 ||
  5970.                     c3))                         c3))
  5971.               foo;
  5972.           if (c1 &&            if (c1 &&
  5973.                   (c2 || c3)            (c2 || c3)
  5974.              }                         }
  5975.  
  5976.     )N    Unclosed parentheses will be searched for at most N lines away.
  5977.           This is just to limit the time needed to search for parentheses.
  5978.           (default 20 lines).
  5979.  
  5980.     *N    Unclosed comments will be searched for at most N lines away.
  5981.           This is just to limit the time needed to search for the start of
  5982.           a comment.  (default 30 lines).
  5983.  
  5984. The defaults, spelled out in full, would be
  5985.     cinoptions=>s,e0,n0,f0,{0,}0,^0,:s,=s,ps,ts,+s,(2s,)20,*30
  5986.  
  5987. Lines are put in column 1 if:
  5988. - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'.
  5989. - It starts with a label (a keyword followed by ':', other than "case" and
  5990.   "default").
  5991. - Any combination of indentations causes the line to have less than 0
  5992.   indentation.
  5993.  
  5994.  
  5995. 12. Copying and moving text                *copy_move*
  5996. ===========================
  5997.  
  5998.                             *quote*
  5999. "<a-zA-Z0-9.%:-">    Use register <a-zA-Z0-9.%:-"> for next delete, yank
  6000.             or put (use uppercase character to append with
  6001.             delete and yank) (<.%:> only work with put).
  6002.  
  6003.                             *:reg* *:registers*
  6004. :reg[isters]        Display the contents of all numbered and named
  6005.             registers.  {not in Vi}
  6006.  
  6007. :reg[isters] {arg}    Display the contents of the numbered and named
  6008.             registers that are mentioned in {arg}.  For example:
  6009.                 :dis 1a
  6010.             to display registers '1' and 'a'.  Spaces are allowed
  6011.             in {arg}.  {not in Vi}
  6012.  
  6013.                             *:di* *:display*
  6014. :di[splay] [arg]    Same as :registers.  {not in Vi}
  6015.  
  6016.                             *y*
  6017. ["x]y{motion}        Yank {motion} text [into register x].
  6018.  
  6019.                             *yy*
  6020. ["x]yy            Yank [count] lines [into register x] (linewise).
  6021.  
  6022.                             *Y*
  6023. ["x]Y            yank [count] lines [into register x] (synonym for
  6024.             yy, linewise).  If you like "Y" to work from the
  6025.             cursor to the end of line (which is more logical,
  6026.             but not Vi-compatible) use ":map Y y$".
  6027.  
  6028.                             *v_y*
  6029. {Visual}["x]y        Yank the highlighed text [into register x] (see the
  6030.             chapter on Visual mode |Visual_mode|).  {not in Vi}
  6031.  
  6032.                             *v_Y*
  6033. {Visual}["x]Y        Yank the highlighted lines [into register x] (see the
  6034.             chapter on Visual mode |Visual_mode|).  {not in Vi}
  6035.  
  6036.                             *:y* *:yank*
  6037. :[range]y[ank] [x]    Yank [range] lines [into register x].
  6038.  
  6039. :[range]y[ank] [x] {count}
  6040.             Yank {count} lines, starting with last line number
  6041.             in [range] (default: current line |cmdline_ranges|),
  6042.             [into register x].
  6043.  
  6044.                             *p*
  6045. ["x]p            Put the text [from register x] after the cursor
  6046.             [count] times.  {Vi: no count}
  6047.  
  6048. ["x]P            or                    *P* *<MiddleMouse>*
  6049. ["x]<MiddleMouse>    Put the text [from register x] before the cursor
  6050.             [count] times.  Using the mouse only works when
  6051.             'mouse' contains 'n' or 'a'.  {Vi: no count}
  6052.  
  6053.                             *:pu* *:put*
  6054. :[line]pu[t] [x]    Put the text [from register x] after [line] (default
  6055.             current line).
  6056.  
  6057. :[line]pu[t]! [x]    Put the text [from register x] before [line] (default
  6058.             current line).
  6059.  
  6060. ["x]]p            or                    *]p* *]<MiddleMouse>*
  6061. ["x]]<MiddleMouse>      Like "p", but adjust the indent to the current line.
  6062.             Using the mouse only works when 'mouse' contains 'n'
  6063.             or 'a'.  {not in Vi}
  6064.  
  6065. ["x][P            or                    *[P*
  6066. ["x]]P            or                    *]P*
  6067. ["x][p            or                    *[p* *[<MiddleMouse>*
  6068. ["x][<MiddleMouse>    Like "P", but adjust the indent to the current line.
  6069.             Using the mouse only works when 'mouse' contains 'n'
  6070.             or 'a'.  {not in Vi}
  6071.  
  6072. These commands can be used to copy text from one place to another.  This is
  6073. done by first getting the text into a register with a yank, delete or change
  6074. command.  The register can then be inserted with a put command.  All registers
  6075. are kept when changing files.  Thus you can also use this to move text from
  6076. one file to another (the CTRL-^ command is a quick way to toggle between two
  6077. files).
  6078.  
  6079. The put commands can be repeated with "." (except for :put) and undone.  If
  6080. the command that was used to get the text into the register was linewise, the
  6081. text will be inserted below ("p") or above ("P") the line where the cursor
  6082. is.  Otherwise the text will be inserted after ("p") or before ("P") the
  6083. cursor.  With the ":put" command the text will always be inserted in the next
  6084. line.  You can exchange two characters with the command sequence "xp".  You
  6085. can exchange two lines with the command sequence "ddp".  You can exchange
  6086. two words with the command sequence "deep" (start with the cursor in the
  6087. blank space before the first word).  The "']" or "`]" command can be used
  6088. after the put command to move the cursor to the end of the inserted text,
  6089. "'[" or "`[" to move the cursor to the start.
  6090.  
  6091. If the command that was used to get the text into the register used
  6092. blockwise Visual mode, the block of text will be inserted before ("P") or
  6093. after ("p") the cursor column, in the current and next lines.  Vim will make
  6094. the whole block of text start in the same column.  Thus the inserted text
  6095. looks the same as when it was yanked or deleted.  Some <Tab> characters may
  6096. be replaced with spaces to make this happen.  However, if the width of the
  6097. block is not a multiple of a <Tab> width and the text after the inserted
  6098. block contains <Tab>s, that text may be misaligned.
  6099.  
  6100. There are five types of registers:            *registers*
  6101. - The unnamed register ""            *quote_quote* *quotequote*
  6102. - 10 numbered registers "0 to "9        *quote_number* *quote0*
  6103. - The small delete register "-            *quote_-* *quote-*
  6104. - 26 named registers "a to "z or "A to "Z    *quote_alpha* *quotea*
  6105. - three read-only registers ":, ". and "%
  6106.  
  6107.     The unnamed register is the register where all text deleted with
  6108. the "d", "c", "s", "x" commands or copied with the yank "y" command is
  6109. placed, regardless of whether or not a specific register was used (e.g.
  6110. "xdd).  The contents of this register are used by any put command (p or P)
  6111. which does not specify a register.  Additionally it can be accessed by the
  6112. name '"'.  This means you have to type two double quotes.  {Vi: register
  6113. contents lost when changing files, no '"'}
  6114.     The numbered registers are filled with yank and delete commands.
  6115. Numbered register 0 is filled with the last yank command, unless another
  6116. register was specified with ["x].  Numbered register 1 is filled with the text
  6117. that was deleted by each delete or change command, unless another register was
  6118. specified or the text is less than one line (text deleted with "x" or "dw"
  6119. will be put in the small delete register).  The contents of register 1 are put
  6120. in 2, 2 in 3, and so forth.  The contents of register 9 are lost.  {Vi:
  6121. numbered register contents are lost when changing files; register 0 does not
  6122. exist}
  6123.     The small delete register is filled with delete commands that delete
  6124. less than one line, except when a register was specified with ["x].
  6125.     The named registers are only filled when you say so.  They are named
  6126. 'a' to 'z' normally.  If you use an uppercase letter, the same registers as
  6127. with the lower case letter is used, but the text is appended to the previous
  6128. register contents.  With a lower case letter the previous contents are lost.
  6129.     The read-only registers are '%', ':' and '.'.  They can only be used
  6130. with the commands "p", "P", ":put" and with CTRL-R.
  6131.                             *quote_.* *quote.*
  6132.     ".    Contains the last inserted text (the same as what is inserted
  6133.         with the insert mode commands CTRL-A and CTRL-@).  Note: this
  6134.         doesn't work with CTRL-R on the command line.  It works a bit
  6135.         differently, like inserting the text instead of putting it
  6136.         ('textwidth' and other options affect what is inserted).
  6137.                             *quote_%* *quote%*
  6138.     "%    Contains the name of the current file.
  6139.                             *quote_:* *quote:*
  6140.     ":    Contains the last command line.  It can be used with "@:",
  6141.         this repeats the last command line.
  6142.  
  6143. If you use a put command without specifying a register, the register that
  6144. was last written to is used (this is also the contents of the unnamed
  6145. register).  If you are confused, use the ":dis" command to find out what will
  6146. be put (all named and numbered registers are displayed; the unnamed register
  6147. is labelled '"').
  6148.  
  6149. The next three commands always work on whole lines.
  6150.  
  6151. :[range]co[py] {address}                *:co* *:copy*
  6152.             Copy the lines given by [range] to below the line
  6153.             given by {address}.
  6154.  
  6155.                             *:t*
  6156. :t            Synonym for copy.
  6157.  
  6158. :[range]m[ove] {address}                *:m* *:move*
  6159.             Move the lines given by [range] to below the line
  6160.             given by {address}.
  6161.  
  6162.  
  6163. 13. Visual mode                        *Visual_mode*
  6164. ===============
  6165.  
  6166. Visual mode is a flexible and easy way to select a piece of text for an
  6167. operator.  It is the only way to select a block of text.  {Vi has no Visual
  6168. mode, the name "visual" is used for Normal mode, to distinguish it from Ex
  6169. mode}
  6170.  
  6171.                             *v*
  6172. v            start Visual mode per character.  {not in Vi}
  6173.  
  6174.                             *V*
  6175. V            start Visual mode linewise.  {not in Vi}
  6176.  
  6177.                             *CTRL-V*
  6178. CTRL-V            start Visual mode blockwise.  {not in Vi}
  6179.  
  6180.                             *v_o*
  6181. o            go to Other end of highlighted text: The current
  6182.             cursor position becomes the start of the highlighted
  6183.             text and the cursor is moved to the Other end of the
  6184.             highlighted text.  {not in Vi}
  6185.  
  6186.                             *gv* *v_gv*
  6187. gv            Start Visual mode with the same area as the previous
  6188.             area and the same mode.  In Visual mode the current and
  6189.             the previous Visual area are exchanged.  {not in Vi}
  6190.  
  6191.                             *<LeftMouse>*
  6192. <LeftMouse>        Set the current cursor position.  If Visual mode is
  6193.             active it is stopped.  Only when 'mouse' option is
  6194.             contains 'n' or 'a'.  If the position is within 'so'
  6195.             lines from the last line on the screen the text is
  6196.             scrolled up.  If the position is within 'so' lines from
  6197.             the first line on the screen the text is scrolled
  6198.             down.  {not in Vi}
  6199.  
  6200.                             *<RightMouse>*
  6201. <RightMouse>        Start Visual mode if it is not active.  The text from
  6202.             the cursor position to the position of the click is
  6203.             highlighted.  If Visual mode was already active move
  6204.             the start or end of the highlighted text, which ever
  6205.             is closest, to the position of the click.  Only when
  6206.             'mouse' option contains 'n' or 'a'.  {not in Vi}
  6207.  
  6208.                             *<LeftRelease>*
  6209. <LeftRelease>        This works like a <LeftMouse>, if it is not a
  6210.             the same position as <LeftMouse>.  In an xterm you
  6211.             won't see the selected area until the button is
  6212.             released.  Only when 'mouse' option contains 'n' or
  6213.             'a'.  {not in Vi}
  6214.  
  6215.  
  6216. To apply an operator on a piece of text:
  6217.     1. mark the start of the text with "v", "V" or CTRL-V
  6218.         The character under the cursor will be used as the start.
  6219.     2. move to the end of the text
  6220.         The text from the start of the Visual mode up to and
  6221.         including the character under the cursor is highlighted.
  6222.     3. hit an operator
  6223.         The highlighted characters will be operated upon.
  6224.  
  6225. The 'highlight' option can be used to set the display mode to use for
  6226. highlighting in Visual mode.
  6227.  
  6228. The highlighted text includes the character under the cursor.  On terminals
  6229. where it is possible to make the cursor invisible the cursor position is
  6230. also highlighted.  On terminals where this is not possible the cursor is
  6231. displayed normally.  If your cursor cannot be made invisible and you want Vim
  6232. to highlight the character under the cursor anyway, you could set the 't_cv'
  6233. and 't_ci' options to something harmless, for example:
  6234.     :set t_cv=^[^[ t_ci=^[^[
  6235.  
  6236. With "v" the text before the start position and after the end position will
  6237. not be highlighted.  However, All uppercase and non-alpha operators, except
  6238. "~", will work on whole lines anyway.  See the list of operators below.
  6239.  
  6240.                             *visual_block*
  6241. With CTRL-V (blockwise Visual mode) the highlighted text will be a rectangle
  6242. between start position and the cursor.  However, some operators work on whole
  6243. lines anyway (see the list below).  The change and substitute operators will
  6244. delete the highlighted text and then start insertion at the top left
  6245. position.
  6246.  
  6247. When the "$" command is used with blockwise Visual mode, the right end of the
  6248. highlighted text will be determined by the longest highlighted line.  This
  6249. stops when a motion command is used that does not move straight up or down.
  6250.  
  6251. If you use <Esc>, click the left mouse button or use any command that
  6252. does a jump to another buffer while in Visual mode, the highlighting stops
  6253. and no text is affected.  Also when you hit "v" in characterwise Visual mode,
  6254. "CTRL-V" in blockwise Visual mode or "V" in linewise Visual mode.  If you hit
  6255. CTRL-Z the highlighting stops and the editor is suspended or a new shell is
  6256. started |CTRL-Z|.
  6257.  
  6258.               new mode after typing:        *v_v* *v_CTRL-V* *v_V*
  6259. old mode             "v"              "CTRL-V"               "V"
  6260.  
  6261. Normal              Visual         blockwise Visual       linewise Visual
  6262. Visual              Normal         blockwise Visual       linewise Visual
  6263. blockwise Visual    Visual         Normal                 linewise Visual
  6264. linewise Visual     Visual         blockwise Visual       Normal
  6265.  
  6266. For moving the end of the block many commands can be used, but you cannot
  6267. use Ex commands, commands that make changes or abandon the file.  Commands
  6268. (starting with) ".pPiIaAO&", CTRL-^, "ZZ", CTRL-], CTRL-T, CTRL-R, CTRL-I
  6269. and CTRL-O cause a beep and Visual mode continues.
  6270.  
  6271. If Visual mode is not active and the "v", "V" or CTRL-V is preceded with a
  6272. count, the size of the previously highlighted area is used for a start.  You
  6273. can then move the end of the highlighted area and give an operator.  The type
  6274. of the old area is used (character, line or blockwise).
  6275. - Linewise Visual mode: The number of lines is multiplied with the count.
  6276. - Blockwise Visual mode: The number of lines and columns is multiplied with
  6277.   the count.
  6278. - Normal Visual mode within one line: The number of characters is multiplied
  6279.   with the count.
  6280. - Normal Visual mode with several lines: The number of lines is multiplied
  6281.   with the count, in the last line the same number of characters is used as
  6282.   in the last line in the previously highlighted area.
  6283. The start of the text is the Cursor position.  If the "$" command was used as
  6284. one of the last commands to extend the highlighted text, the area will be
  6285. extended to the rightmost column of the longest line.
  6286.  
  6287. If you want to highlight exactly the same area as the last time, you can use
  6288. "gv" |gv| |v_gv|.
  6289.  
  6290. The operators that can be used are:
  6291.     ~    switch case                    |v_tilde|
  6292.     d    delete                        |v_d|
  6293.     c    change                        |v_c|
  6294.     y    yank                        |v_y|
  6295.     >    shift right (1)(*)                |v_>|
  6296.     <    shift left (1)(*)                |v_<|
  6297.     !    filter through external command (1)        |v_!|
  6298.     =    filter through 'equalprg' option command (1)    |v_=|
  6299.     Q    format lines to 'textwidth' length (1)(obsolete)|v_Q|
  6300.     gq    format lines to 'textwidth' length (1)        |v_gq|
  6301.  
  6302. The objects that can be used are:
  6303.     a    word                        |v_a|
  6304.     A    WORD (see |WORD|)                |v_A|
  6305.     s    sentence                    |v_s|
  6306.     p    paragraph                    |v_p|
  6307.     P    block                        |v_P|
  6308.  
  6309. Additionally the following commands can be used:
  6310.     :    start ex command for highlighted lines (1)    |v_:|
  6311.     r    change                        |v_r|
  6312.     C    change (2)                    |v_C|
  6313.     R    change (2)                    |v_R|
  6314.     x    delete                        |v_x|
  6315.     D    delete (2)                    |v_D|
  6316.     X    delete (2)                    |v_X|
  6317.     Y    yank (2)                    |v_Y|
  6318.     J    join (1)                    |v_J|
  6319.     U    make uppercase                    |v_U|
  6320.     u    make lowercase                    |v_u|
  6321.     ^]    find tag                    |v_CTRL-]|
  6322.  
  6323. (1): always whole lines, see |:visual_example|
  6324. (2): whole lines when not using CTRL-V
  6325. (*): in a future a blockwise shift will move the block only, not whole
  6326.      lines.
  6327.  
  6328. Note that the ":vmap" command can be used to specifically map keys in Visual
  6329. mode.
  6330.  
  6331. If you want to give a register name using the """ command, do this just before
  6332. typing the operator character: "v{move around}"xd".
  6333.  
  6334. If you want to give a count to the command, do this just before typing the
  6335. operator character: "v{move around}3>" (move lines 3 indents to the right).
  6336.  
  6337.                             *repeat_Visual*
  6338. When repeating a Visual mode operator, the operator will be applied to the
  6339. same amount of text as the last time:
  6340. - Linewise Visual mode: The same number of lines.
  6341. - Blockwise Visual mode: The same number of lines and columns.
  6342. - Normal Visual mode within one line: The same number of characters.
  6343. - Normal Visual mode with several lines: The same number of lines, in the
  6344.   last line the same number of characters as in the last line the last time.
  6345. The start of the text is the Cursor position.  If the "$" command was used as
  6346. one of the last commands to extend the highlighted text, the repeating will
  6347. be applied up to the rightmost column of the longest line.
  6348.  
  6349.                             *:visual_example*
  6350. Currently the ":" command works on whole lines only.  When you select part of
  6351. a line, doing something like ":!date" will replace the whole line.  If you
  6352. want only part of the line to be replaced you will have to make a mapping for
  6353. it.  In a future release ":" may work on partial lines.
  6354.  
  6355. Here is an example, to replace the selected text with the output of "date":
  6356.  
  6357. :vmap _a <Esc>a<CR><Esc>`\<i<CR><Esc>!!date<CR>kJJ
  6358.  
  6359. (In the <> notation |<>|, when typing it you should type it literally; you
  6360. need to remove the 'B' and '<' flags from 'cpoptions')
  6361.  
  6362. What this does is:
  6363. <Esc>        stop Visual mode
  6364. a<CR><Esc>    break the line after the Visual area
  6365. `\<        jump to the start of the Visual area
  6366. i<CR><Esc>    break the line before the Visual area
  6367. !!date<CR>    filter the Visual text through date
  6368. kJJ        Join the lines again
  6369.  
  6370.  
  6371. 14. Various commands                    *various*
  6372. ====================
  6373.  
  6374.                             *CTRL-L*
  6375. CTRL-L            Clear and redraw the screen.
  6376.  
  6377.                             *N<Del>*
  6378. <Del>            When entering a number: Remove the last digit.
  6379.             Note: if you like to use <BS> for this, add this
  6380.             mapping to your .vimrc:
  6381.                 :map CTRL-V <BS>   CTRL-V <Del>
  6382.             See |:fixdel| if your <Del> key does not do what you
  6383.             want.
  6384.  
  6385. :as[cii]    or                    *ga* *:as* *:ascii*
  6386. ga            Print the ascii value of the character under the
  6387.             cursor in decimal, hexadecimal and octal.  For
  6388.             example, when the cursor is on a 'R':
  6389.                 <R>  82,  Hex 52,  Octal 122
  6390.             When the character is a non-standard ASCII character,
  6391.             but printable according to the 'isprint' option, the
  6392.             non-printable version is also given.  When the
  6393.             character is larger than 127, the <M-x> form is also
  6394.             printed.  For example:
  6395.                 <~A>  <M-^A>  129,  Hex 81,  Octal 201
  6396.                 <p>  <|~>  <M-~>  254,  Hex fe,  Octal 376
  6397.             (where <p> is a special character)
  6398.             The <Nul> character in a file is stored internally as
  6399.             <NL>, but it will be shown as:
  6400.                 <^@>  0,  Hex 00,  Octal 000
  6401.             Mnemonic: Get Ascii value.  {not in Vi}
  6402.  
  6403.                             *:p* *:print*
  6404. :[range]p[rint]        Print [range] lines (default current line).
  6405.  
  6406. :[range]p[rint] {count}
  6407.             Print {count} lines, starting with [range] (default
  6408.             current line |cmdline_ranges|).
  6409.  
  6410.                             *:l* *:list*
  6411. :[range]l[ist] [count]
  6412.             Same as :print, but display unprintable characters
  6413.             with '^'.
  6414.  
  6415.                             *:nu* *:number*
  6416. :[range]nu[mber] [count]
  6417.             Same as :print, but precede each line with its line
  6418.             number.  (See also 'highlight' option).
  6419.  
  6420.                             *:#*
  6421. :[range]# [count]    synonym for :number.
  6422.  
  6423.                             *:=*
  6424. :=            Print the cursor line number.
  6425.  
  6426. :norm[al][!] {commands}                    *:norm* *:normal*
  6427.             Execute Normal mode commands {commands}.  This makes
  6428.             it possible to execute normal mode commands typed on
  6429.             the command line.  {commands} is executed like it is
  6430.             typed.  For undo all commands are undone together.  If
  6431.             the [!] is given, mappings will not be used.  If
  6432.             {commands} does not finish a command, more characters
  6433.             need to be typed.  Mostly useful for autocommands.
  6434.             This command cannot be followed by another command,
  6435.             since any '|' is considered part of the command.
  6436.             {not in vi}
  6437.  
  6438.                             *:sh* *:shell*
  6439. :sh[ell]        Escape to a shell (name from 'shell' option).
  6440.  
  6441.                             *:!cmd* *:!*
  6442. :!{cmd}            Execute {cmd} with the shell.  See also the 'shell'
  6443.             and 'shelltype' option.  Any '!' in {cmd} is replaced
  6444.             with the previous external command (see also
  6445.             'cpoptions').  But not when there is a backslash
  6446.             before the '!', then that backslash is removed.
  6447.             Example: ":!ls" followed by ":!echo ! \! \\!"
  6448.             executes "echo ls ! \!".  Also see |shell_window|.
  6449.  
  6450.                             *:!!*
  6451. :!!            Repeat last ":!{cmd}".
  6452.  
  6453.                             *:ve* *:version*
  6454. :ve[rsion]        Print the version number of the editor.  If the
  6455.             compiler used understands "__DATE__" the compilation
  6456.             date is mentioned.  Otherwise a fixed release-date is
  6457.             shown.  The following lines contain information about
  6458.             which options were defined when Vim was compiled.
  6459.  
  6460. :ve[rsion] {nr}        Set the version number to {nr}.  Used in .vimrc files.
  6461.             When omitted Vim will give a warning message. If {nr}
  6462.             is higher than the current Vim version this will
  6463.             result in an error message.  {not in Vi}
  6464.  
  6465.                             *K*
  6466. K            Run a program to lookup the keyword under the
  6467.             cursor.  The name of the program is given with the
  6468.             'keywordprg' (kp) option (default is "man").  The
  6469.             keyword is formed of letters, numbers and the
  6470.             characters in 'iskeyword'.  The keyword under or
  6471.             right of the cursor is used.  The same can be done
  6472.             with the command
  6473.                 ":!{program} {keyword}".
  6474.             There is an example of a program to use in the tools
  6475.             directory of Vim.  It is called 'ref' and does a
  6476.             simple spelling check.
  6477.             If 'keywordprg' is empty, the ":help" command is used.
  6478.             {not in Vi}
  6479.  
  6480.                             *v_K*
  6481. {Visual}K        Like "K", but use the visually highlighted text for
  6482.             the keyword.  Only works when the highlighted text is
  6483.             not more than one line.  {not in Vi}
  6484.  
  6485. [N]gs                            *gs* *:sl* *:sleep*
  6486. :[N]sl[eep] [N]        Do nothing for [N] seconds.  Can be interrupted with
  6487.             CTRL-C (CTRL-break on MS-DOS).  "gs" stands for "goto
  6488.             sleep".  While sleeping the cursor is positioned in
  6489.             the text (if visible).  {not in Vi}
  6490.  
  6491.  
  6492. 15. Repeating commands                    *repeating*
  6493. ======================
  6494.  
  6495. 15.1 Single repeats                    *single_repeat*
  6496.  
  6497.                             *.*
  6498. .            Repeat last change with count replaced with [count].
  6499.  
  6500. Simple changes can be repeated with the "." command.  Without a count, the
  6501. count of the last change is used.  If you enter a count, it will replace the
  6502. last one.  If the last change included a specification of a numbered register,
  6503. the register number will be incremented.  See the section on undo and redo for
  6504. an example how to use this |undo_redo|.  Note that when repeating a command
  6505. that used a Visual selection, the same SIZE of area is used, see
  6506. |repeat_Visual|.
  6507.  
  6508.                             *@:*
  6509. @:            Repeat last command line [count] times.
  6510.  
  6511.  
  6512. 15.2 Multiple repeats                    *multi_repeat*
  6513.  
  6514.                             *:g* *:global*
  6515. :[range]g[lobal]/{pattern}/[cmd]
  6516.             Execute the Ex command [cmd] (default ":p") on the
  6517.             lines within [range] where {pattern} matches.
  6518.  
  6519. :[range]g[lobal]!/{pattern}/[cmd]
  6520.             Execute the Ex command [cmd] (default ":p") on the
  6521.             lines within [range] where {pattern} does NOT match.
  6522.  
  6523.                             *:v* *:vglobal*
  6524. :[range]v[global]/{pattern}/[cmd]
  6525.             Same as :g!.
  6526.  
  6527. The global commands work by first scanning through the [range] lines and
  6528. marking each line where a match occurs.  In a second scan the [cmd] is
  6529. executed for each marked line with its line number prepended.  If a line is
  6530. changed or deleted its mark disappears.  The default for [range] is the whole
  6531. buffer (1,$).  Use "CTRL-C" to interrupt the command.  If an error message is
  6532. given for a line the global command aborts.
  6533.  
  6534. To repeat a non-Ex command, you will have to put the command in a file and
  6535. use "source!".  For example:
  6536.     :g/pat/so! scriptfile
  6537. Make sure that the scriptfile ends with a whole command, otherwise Vim will
  6538. wait for you to type the rest of the command for each match.  The screen will
  6539. not have been updated, so you don't know what you are doing.
  6540.  
  6541. The undo/redo command will undo/redo the whole global command at once.
  6542. The previous context mark will only be set once (with "''" you go back to
  6543. where the cursor was before the global command).
  6544.  
  6545. The global command sets both the last used search pattern and the last used
  6546. substitute pattern (this is vi compatible).  This makes it easy to globally
  6547. replace a string:
  6548.     :g/pat/s//PAT/g
  6549. This replaces all occurences of "pat" with "PAT".  The same can be done with:
  6550.     :%s/pat/PAT/g
  6551. Which is two characters shorter!
  6552.  
  6553.  
  6554. 15.3 Complex repeats                    *complex_repeat*
  6555.  
  6556.                             *q*
  6557. q<0-9a-zA-Z">        Record typed characters into register <0-9a-zA-Z">
  6558.             (uppercase to append).  The 'q' command is disabled
  6559.             while executing a register.  {Vi: no recording}
  6560.  
  6561. q            Stops recording.  (Implementation note: The 'q' that
  6562.             stops recording is not stored in the register, unless
  6563.             it was the result of a mapping)  {Vi: no recording}
  6564.  
  6565.                             *@*
  6566. @<0-9a-z".>        Execute the contents of register <0-9a-z".> [count]
  6567.             times.  Note that register '%' (name of the current
  6568.             file) cannot be used.  See also |@:|.  {Vi: only named
  6569.             registers}
  6570.  
  6571.                             *@@*
  6572. @@            Repeat the previous @<0-9a-z":> [count] times.
  6573.  
  6574.                             *:@*
  6575. :[addr]@<0-9a-z">    Execute the contents of register <0-9a-z"> as an Ex
  6576.             command.  First set cursor at line [addr] (default is
  6577.             current line).  When the last line in the register does
  6578.             not have a <CR> it will be added automatically when
  6579.             the 'e' flag is present in 'cpoptions'.  {Vi: only in
  6580.             some versions} Future: Will execute the register for
  6581.             each line in the address range.
  6582.  
  6583. :[addr]@:        Repeat last command line [count] times.  First set
  6584.             cursor at line [addr] (default is current line).
  6585.             {Vi: only in some versions}
  6586.  
  6587.                             *:@@*
  6588. :[addr]@@        Repeat the previous :@<0-9a-z">.  First set cursor at
  6589.             line [addr] (default is current line).  {Vi: only in
  6590.             some versions}
  6591.  
  6592.                             *:so* *:source*
  6593. :so[urce] {file}    Read Ex commands from {file}.
  6594.  
  6595. :so[urce]! {file}    Read Vim commands from {file}.  {not in Vi}
  6596.  
  6597. All commands and command sequences can be repeated by putting them in a named
  6598. register and then executing it.  There are two ways to get the commands in the
  6599. register:
  6600. - Use the record command "q".  You type the commands once, and while they are
  6601.   being executed they are stored in a register.  Easy, because you can see
  6602.   what you are doing.  If you make a mistake, 'put' the register into the
  6603.   file, edit the command sequence, and then delete it into the register
  6604.   again.  You can continue recording by appending to the register (use an
  6605.   uppercase letter).
  6606. - Delete or yank the command sequence into the register.
  6607.  
  6608. Often used command sequences can be put under a function key with the ':map'
  6609. command.
  6610.  
  6611. An alternative is to put the commands in a file, and execute them with the
  6612. ':source!' command.  Useful for long command sequences.  Can be combined with
  6613. the ':map' command to put complicated commands under a function key.
  6614.  
  6615. The ':source' command reads Ex commands from a file line by line.  You will
  6616. have to type any needed keyboard input.  The ':source!' command reads from a
  6617. script file character by character, interpreting each character as if you
  6618. typed it.
  6619.  
  6620. Example: When you give the ":!ls" command you are asked to "hit return to
  6621. continue".  If you ':source' a file with the line "!ls" in it, you will have
  6622. to type the return yourself.  But if you ':source!' a file with the line
  6623. ":!ls" in it, the next characters from that file are read until a <CR> is
  6624. found.  You will not have to type <CR> yourself, unless ":!ls" was the last
  6625. line in the file.
  6626.  
  6627. It is possible to put ':source[!]' commands in the script file, so you can
  6628. make a top-down hierarchy of script files.  The ':source' command can be
  6629. nested as deep as the number of files that can be opened at one time (about
  6630. 15).  The ':source!' command can be nested up to 15 levels deep.
  6631.  
  6632. In script files terminal-dependent key codes are represented by
  6633. terminal-independent two character codes.  This means that they can be used
  6634. in the same way on different kinds of terminals.  The first character of a
  6635. key code is 0x80 or 128, shown on the screen as "~@".  The second one can be
  6636. found in the list |key_notation|.  Any of these codes can also be entered
  6637. with CTRL-V followed by the three digit decimal code.  This does NOT work for
  6638. the <t_xx> termcap codes, these can only be used in mappings.
  6639.  
  6640.                             *:source_crnl*
  6641. MS-DOS, Win32 and OS/2: Files that are read with ":source" normally have
  6642. <CR>-<NL> line separators.  These always work.  If you are using a file with
  6643. <NL> line separators (for example, a file made on Unix), this will be
  6644. recognized if you have 'textauto' on and the first line does not end in a
  6645. <CR>.  This fails if the first line has something like ":map <F1> :help^M",
  6646. where "^M" is a <CR>.  If the first line ends in a <CR>, but following ones
  6647. don't, you will get an error message, because the <CR> from the first lines
  6648. will be lost.
  6649.  
  6650.  
  6651. 16. Undo and redo                    *undo_redo*
  6652. =================
  6653.  
  6654. <Undo>        or                    *undo* *<Undo>* *u*
  6655. u            Undo [count] changes.  {Vi: only one level}
  6656.  
  6657.                             *:u* *:undo*
  6658. :u[ndo]            Undo one change.  {Vi: only one level}
  6659.  
  6660.                             *CTRL-R*
  6661. CTRL-R            Redo [count] changes which were undone.  {Vi: redraw
  6662.             screen}
  6663.  
  6664.                             *:red* *:redo*
  6665. :red[o]            Redo one change which was undone.  {Vi: no redo}
  6666.  
  6667.                             *U*
  6668. U            Undo all latest changes on one line.  {Vi: while not
  6669.             moved off of it}
  6670.  
  6671. The last changes are remembered.  You can go back in time with the "u"
  6672. command.  You can then go forward again with the 'CTRL-R' command.  If you
  6673. make a new change after the "u" command, the 'CTRL-R' will not be possible
  6674. anymore.  The number of changes that are remembered is set with the
  6675. 'undolevels' option.  If it is zero, the old fashioned Vi undo is present:
  6676. one level of undo and undo undoes itself.  If it is negative no undo is
  6677. possible.  Use this if you are running out of memory.
  6678.  
  6679. The "U" command is treated by undo/redo just like any other command.  Thus a
  6680. "u" command undos a "U" command and a 'CTRL-R' command redoes it again.  When
  6681. mixing "U", "u" and 'CTRL-R' you will notice that the "U" command will
  6682. restore the situation of a line to before the previous "U" command.  This may
  6683. be confusing.  Try it out to get used to it.
  6684.  
  6685. When all changes have been undone the buffer is not considered to be changed.
  6686. Vim can then be exit with ":q" instead of ":q!".  {this is not in Vi}
  6687.  
  6688. The numbered registers can also be used for undoing deletes.  Each time you
  6689. delete text, it is put into register "1.  The contents of register "1 are
  6690. shifted to "2, etc.  The contents of register "9 are lost.  You can now get
  6691. back the most recent deleted text with the put command: '"1P'.  (also, if the
  6692. deleted text was the result of the last delete or copy operation, 'P' or 'p'
  6693. also works as this puts the contents of the unnamed register).  You can get
  6694. back the text of three deletes ago with '"3P'.
  6695.  
  6696. If you want to get back more than one part of deleted text, you can use a
  6697. special feature of the repeat command ".".  It will increase the number of the
  6698. register used.  So if you first do ""1P", the following "." will result in a
  6699. '"2P'.  Repeating this will result in all numbered registers being inserted.
  6700.  
  6701. Example:    If you deleted text with 'dd....' it can be restored with
  6702.         '"1P....'.
  6703.  
  6704. If you don't know in which register the deleted text is, you can use the
  6705. :display command.  An alternative is to try the first register with '"1P', and
  6706. if it is not what you want do 'u.'.  This will remove the contents of the
  6707. first put, and repeat the put command for the second register.  Repeat the
  6708. 'u.' until you got what you want.
  6709.  
  6710.  
  6711. 17. Key mapping                        *key_mapping*
  6712. ===============
  6713.  
  6714. There are commands to enter new mappings, remove mappings and list mappings:
  6715.  
  6716. :map    {lhs} {rhs}                    *:map*
  6717. :nm[ap] {lhs} {rhs}                    *:nm* *:nmap*
  6718. :vm[ap] {lhs} {rhs}                    *:vm* *:vmap*
  6719. :map!   {lhs} {rhs}                    *:map!*
  6720. :im[ap] {lhs} {rhs}                    *:im* *:imap*
  6721. :cm[ap] {lhs} {rhs}                    *:cm* *:cmap*
  6722.             Map the key sequence {lhs} to {rhs} for the modes
  6723.             where the map command applies.
  6724.  
  6725.  
  6726. :no[remap]  {lhs} {rhs}                    *:no*  *:noremap*
  6727. :nn[oremap] {lhs} {rhs}                    *:nn*  *:nnoremap*
  6728. :vn[oremap] {lhs} {rhs}                    *:vn*  *:vnoremap*
  6729. :no[remap]! {lhs} {rhs}                    *:no!* *:noremap!*
  6730. :ino[remap] {lhs} {rhs}                    *:ino* *:inoremap*
  6731. :cno[remap] {lhs} {rhs}                    *:cno* *:cnoremap*
  6732.             Map the key sequence {lhs} to {rhs} for the modes
  6733.             where the map command applies.  Disallow mapping of
  6734.             {rhs}. {not in Vi}
  6735.  
  6736.  
  6737. :unm[ap]  {lhs}                        *:unm*  *:unmap*
  6738. :nun[map] {lhs}                        *:nun*  *:nunmap*
  6739. :vu[nmap] {lhs}                        *:vu*   *:vunmap*
  6740. :unm[ap]! {lhs}                        *:unm!* *:unmap!*
  6741. :iu[nmap] {lhs}                        *:iu*   *:iunmap*
  6742. :cu[nmap] {lhs}                        *:cu*   *:cunmap*
  6743.             Remove the mapping of {lhs} for the modes where the
  6744.             map command applies.
  6745.  
  6746. :mapc[lear]                        *:mapc*  *:mapclear*
  6747. :nmapc[lear]                        *:nmapc* *:nmapclear*
  6748. :vmapc[lear]                        *:vmapc* *:vmapclear*
  6749. :mapc[lear]!                        *:mapc!* *:mapclear!*
  6750. :imapc[lear]                        *:imapc* *:imapclear*
  6751. :cmapc[lear]                        *:cmapc* *:cmapclear*
  6752.             Remove all mappings for the modes where the map
  6753.             command applies.  {not in Vi}
  6754.  
  6755. :map
  6756. :nm[ap]
  6757. :vm[ap]
  6758. :map!
  6759. :im[ap]
  6760. :cm[ap]
  6761.             List all key mappings for the modes where the map
  6762.             command applies.
  6763.  
  6764. :map    {lhs}                        *:map_l*
  6765. :nm[ap] {lhs}                        *:nmap_l*
  6766. :vm[ap] {lhs}                        *:vmap_l*
  6767. :map!   {lhs}                        *:map_l!*
  6768. :im[ap] {lhs}                        *:imap_l*
  6769. :cm[ap] {lhs}                        *:cmap_l*
  6770.             List the key mappings for the key sequences starting
  6771.             with {lhs} in the modes where the map command applies.
  6772.             {not in Vi}
  6773.  
  6774. These commands are used to map a key or key sequence to a string of
  6775. characters.  You can use this to put command sequences under function keys,
  6776. translate one key into another, etc.  See the "Options" chapter below for how
  6777. to save and restore the current mapping |options|.
  6778.  
  6779. There are four sets of mappings
  6780. - For Insert mode. These are also used in Replace mode.
  6781. - For Command-line mode: When entering a ":" or "/" command.
  6782. - For Normal mode: When typing commands.
  6783. - For Visual mode: When typing commands while the Visual area is highlighted.
  6784.  
  6785. Overview of which map command works in which mode:
  6786.  
  6787.     commands:                      modes:
  6788.                       Normal  Visual  Insert Command-line
  6789. :map   :noremap   :unmap   :mapclear         X       X       .         .
  6790. :nmap  :nnoremap  :nunmap  :nmapclear        X       .       .         .
  6791. :vmap  :vnoremap  :vunmap  :vmapclear        .       X       .         .
  6792. :map!  :noremap!  :unmap!  :mapclear!        .       .       X         X
  6793. :imap  :inoremap  :iunmap  :imapclear        .       .       X         .
  6794. :cmap  :cnoremap  :cunmap  :cmapclear        .       .       .         X
  6795.  
  6796. The original Vi did not have separate mappings for Normal/Visual mode and
  6797. Insert/Command-line mode.  Therefore the ":map" and ":map!" commands enter
  6798. and display mappings for both.  In Vim you can use the ":nmap", "vmap",
  6799. ":cmap" and ":imap" commands to enter mappings for each mode separately.
  6800. When listing mappings the character in column 1 is
  6801.  
  6802.     char        mode
  6803.     <Space>        Normal and Visual
  6804.      n        Normal
  6805.      v        Visual
  6806.      !        Insert and Command-line
  6807.      i        Insert
  6808.      c        Command-line
  6809.  
  6810. Note: When using mappings for Visual mode, you can use the '<' mark, which
  6811. is the start of the last selected Visual area |'<|.
  6812.  
  6813. Everything from the first non-blank after {lhs} up to the end of the line
  6814. (or '|') is considered to be part of {rhs}.  This allows the {rhs} to end
  6815. with a space.
  6816.  
  6817.                             *map_backslash*
  6818. Note that only CTRL-V is mentioned here as a special character for mappings
  6819. and abbreviations.  When 'cpoptions' does not contain 'B', a backslash can
  6820. also be used like CTRL-V.  The <> notation can be fully used then |<>|.
  6821.  
  6822.                             *map_space_in_lhs*
  6823. To include a space in {lhs} precede it with a CTRL-V (type two CTRL-Vs for
  6824. each space).
  6825.                             *map_space_in_rhs*
  6826. If you want a {rhs} that starts with a space, precede {rhs} with a single
  6827. CTRL-V (you have to type CTRL-V two times).
  6828.                             *map_empty_rhs*
  6829. You can create an empty {rhs} by typing nothing after a single CTRL-V (you
  6830. have to type CTRL-V two times).
  6831.  
  6832.                             *map_bar*
  6833. It is not possible to put a comment after this command, because the '"'
  6834. character is considered to be part of the {rhs}.  To put a '|' in {rhs}
  6835. escape it with a backslash or a CTRL-V (to get one CTRL-V you have to type
  6836. it twice).  When 'b' is present in 'cpoptions', only CTRL-V can be used, "\|"
  6837. will be recognized as a mapping ending in a '\' and then another command.  This
  6838. is vi compatible, but unlogical.  Summary:
  6839.     :map _l :!ls \| more^M        works in Vim when 'b' is not in 'cpo'
  6840.     :map _l :!ls ^V| more^M        works always, in Vim and vi
  6841.  
  6842. To avoid mapping of the characters you type in insert or Command-line mode,
  6843. type a CTRL-V first.  The mapping in Insert mode is disabled if the 'paste'
  6844. option is on.
  6845.  
  6846. Note that when an error is enountered (that causes an error message) the rest
  6847. of the mapping is not executed.  This is vi-compatible.
  6848.  
  6849. Note that the second character (argument) of the commands @zZtTfF[]rm'`"v
  6850. and CTRL-X is not mapped.  This was done to be able to use all the named
  6851. registers and marks, even when the command with the same name has been
  6852. mapped.
  6853.  
  6854. Some examples (given as you type them; e.g., the "^V" is CTRL-V which you
  6855. type, but will not show up on the screen):
  6856.  
  6857.     :map g /foo^V^Mcwbar^V^[    (replace next "foo" with "bar")
  6858.     :map! qq quadrillion questions
  6859.  
  6860. Vim will compare what you type with the start of a mapped sequence.  If there
  6861. is an incomplete match, it will get more characters until there either is a
  6862. complete match or until there is no match at all.  Example: If you map! "qq",
  6863. the first 'q' will not appear on the screen until you type another
  6864. character.  This is because Vim cannot know if the next character will be a
  6865. 'q' or not.  If the 'timeout' option is on (which is the default) Vim will
  6866. only wait for one second (or as long as specified with the 'timeoutlen'
  6867. option).  After that it assumes that the 'q' is to be interpreted as such.  If
  6868. type slowly, or your system is slow, reset the 'timeout' option.  Then you
  6869. might want to set the 'ttimeout' option.  See the "Options" chapter |options|.
  6870.  
  6871.                         *recursive_mapping*
  6872. If you include the {lhs} in the {rhs} you have a recursive mapping.  When
  6873. {lhs} is typed, it will be replaced with {rhs}.  When the {lhs} which is
  6874. included in {rhs} is encountered it will be replaced with {rhs}, and so on.
  6875. This makes it possible to repeat a command an infinite number of times.  The
  6876. only problem is that the only way to stop this is by causing an error.  The
  6877. macros to solve a maze uses this, look there for an example.  There is one
  6878. exception: If the {rhs} starts with {lhs}, that part is not mapped again.
  6879. For example:
  6880.     :map a ab
  6881. will execute the "a" command and insert a 'b' in the text.  The 'a' in the
  6882. {rhs} will not be mapped again.
  6883.  
  6884. If you want to exchange the meaning of two keys you should use the :noremap
  6885. command.  For example:
  6886.     :noremap k j
  6887.     :noremap j k
  6888. This will exchange the cursor up and down commands.
  6889.  
  6890. With the normal :map command, when the 'remap' option is on, mapping takes
  6891. place until the text is found not to be a part of a {lhs}.  For example, if
  6892. you use:
  6893.     :map x y
  6894.     :map y x
  6895. Vim will replace x with y, and then y with x, etc.  When this has happened
  6896. 'maxmapdepth' times (default 1000), Vim will give the error message
  6897. "recursive mapping".
  6898.  
  6899. See the file "index" for keys that are not used and thus can be mapped
  6900. without losing any builtin function.  I suggest you use function keys,
  6901. and meta-keys.  If you are prepared to lose a command that you hardly ever use
  6902. you can make mappings that start with '_' or '-'.  You can also use
  6903. ":help <key>^D" to find out if a key is used for some command.  (<key> is the
  6904. specific key you want to find out about, ^D is CTRL-D).
  6905.  
  6906. If you include an undo command inside a mapped sequence, this will bring the
  6907. text back in the state before executing the macro.  This is compatible with
  6908. the original Vi, as long as there is only one undo command in the mapped
  6909. sequence (having two undo commands in a mapped sequence did not make sense
  6910. in the original Vi, you would get back the text before the first undo).
  6911.  
  6912. There are three ways to map a special key:
  6913. 1. The Vi-compatible method: Map the key code.  Often this is a sequence that
  6914.    starts with <Esc>.  To enter a mapping like this you type ":map " and then
  6915.    you have to type CTRL-V before hitting the function key.  Note that when
  6916.    the key code for the key is in the termcap (the t_ options), it will
  6917.    automatically be translated into the internal code and become the second
  6918.    way of mapping (unless the 'k' flag is included in 'cpoptions').
  6919. 2. The second method is to use the internal code for the function key.  To
  6920.    enter such a mapping type CTRL-K and then hit the function key, or use
  6921.    the form "#1", "#2", .. "#9", "#0", "<Up>", "<S-Down>", "<S-F7>", etc.
  6922.    (see table of keys |key_notation|, all keys from <Up> can be used).  The
  6923.    first ten function keys can be defined in two ways: Just the number, like
  6924.    "#2", and with "<F>", like "<F2>".  Both stand for function key 2.  "#0"
  6925.    refers to function key 10, defined with option 't_f10', which may be
  6926.    function key zero on some keyboards.  The <> form cannot be used when
  6927.    'cpoptions' includes the '<' flag.
  6928. 3. Use the termcap entry, with the form <t_xx>, where "xx" is the name of the
  6929.    termcap entry.  Any string entry can be used.  For example:
  6930.        :map <t_F3> G
  6931.    Maps function key 13 to "G".  This does not work if 'cpoptions' includes
  6932.    the '<' flag.
  6933.  
  6934. The advantage of the second and third method is that the mapping will work on
  6935. different terminals without modification (the function key will be
  6936. translated into the same internal code or the actual key code, no matter what
  6937. terminal you are using.  The termcap must be correct for this to work, and you
  6938. must use the same mappings).
  6939.  
  6940. DETAIL: Vim first checks if a sequence from the keyboard is mapped.  If it
  6941. isn't the terminal key codes are tried (see section 20.2
  6942. |terminal_options|).  If a terminal code is found it is replaced with the
  6943. internal code.  Then the check for a mapping is done again (so you can map an
  6944. internal code to something else).  What is written into the script file
  6945. depends on what is recognized.  If the terminal key code was recognized as a
  6946. mapping the key code itself is written to the script file.  If it was
  6947. recognized as a terminal code the internal code is written to the script
  6948. file.
  6949.  
  6950.  
  6951. 18. Recovery after a crash                *crash_recovery*
  6952. ==========================
  6953.  
  6954. You have spent several hours typing in that text that has to be finished
  6955. next morning, and then disaster strikes: Your computer crashes.
  6956.  
  6957.             DON'T PANIC!
  6958.  
  6959. You can recover most of your changes from the files that Vim uses to store
  6960. the contents of the file.  Mostly you can recover your work with one command:
  6961.     vim -r filename
  6962.  
  6963. 18.1 The swap file                    *swap_file*
  6964.  
  6965. Vim stores the things you changed in a swap file.  Using the original file
  6966. you started from plus the swap file you can mostly recover your work.
  6967.  
  6968. You can see the name of the current swap file being used with the command:
  6969.  
  6970.     :sw[apname]                    *:sw* *:swapname*
  6971.  
  6972. The name of the swap file is normally the same as the file you are editing,
  6973. with the extension ".swp".  On MS-DOS and Win32 machines and when the
  6974. 'shortname' option is on, any '.' in the original file name is replaced with
  6975. '_'.  If this file already exists (e.g., when you are recovering from a crash)
  6976. a warning is given and another extension is used, ".swo", ".swn", etc.  An
  6977. existing file will never be overwritten.  The swap file is deleted as soon as
  6978. Vim stops editing the file.
  6979.  
  6980. Technical: The replacement of '.' with '_' is done to avoid problems with
  6981.        MS-DOS compatible filesystems (e.g., crossdos, multidos).  If Vim
  6982.        is able to detect that the file is on an MS-DOS-like filesystem, a
  6983.        flag is set that has the same effect as the 'shortname' option.
  6984.        This flag is reset when you start editing another file.
  6985.  
  6986.        If the ".swp" filename already exists, the last character is
  6987.        decremented until there is no file with that name or ".swa" is
  6988.        reached.  In the last case, no swap file is created.
  6989.  
  6990. By setting the 'directory' option you can place the swap file in another place
  6991. than where the edited file is.
  6992. Advantages:
  6993. - You will not pollute the directories with ".swp" files.
  6994. - When the 'directory' is on another partition, reduce the risk of damaging
  6995.   the file system where the file is (in a crash).
  6996. Disadvantages:
  6997. - You can get name collisions from files with the same name but in different
  6998.   directories (although Vim tries to avoid that by comparing the path name).
  6999.   This will result in bogus ATTENTION warning messages.
  7000. - When you use your home directory, and somebody else tries to edit the same
  7001.   file, he will not see your swap file and will not get the ATTENTION waring
  7002.   message.
  7003. On the Amiga you can also use a recoverable ram disk, but there is no 100%
  7004. guarantee that this works.  Putting swap files in a normal ram disk (like RAM:
  7005. on the Amiga) or in a place that is cleared when rebooting (like /tmp on Unix)
  7006. makes no sense, you will lose the swap file in a crash.
  7007.  
  7008. If you want to put swap files in a fixed place, put a command resembling the
  7009. following ones in your .vimrc:
  7010.     :set dir=dh2:tmp    (for Amiga)
  7011.     :set dir=~/tmp        (for Unix)
  7012.     :set dir=c:\\tmp    (for MS-DOS and Win32)
  7013. This is also very handy when editing files on floppy.  Of course you will have
  7014. to create that "tmp" directory for this to work!
  7015.  
  7016. When starting to edit a file, Vim checks if a swap file already exists for
  7017. that file.  If there is one, you will get a message indicating that something
  7018. is wrong:
  7019.  
  7020.     ATTENTION
  7021.     Found a swap file by the name "../doc/vim_ref.txt.swp"
  7022.              dated: Thu May 16 11:46:31 1996
  7023.          file name: ~mool/vim/vim/doc/vim_ref.txt
  7024.          host name: Kibaale
  7025.          user name: mool
  7026.         process ID: 211 (still running)
  7027.     While opening file "../doc/vim_ref.txt"
  7028.              dated: Wed May 15 21:38:40 1996
  7029.  
  7030. You are to take one of two actions:
  7031.  
  7032. 1. Quit editing this file, because another edit session is active on this
  7033.    file.  Continuing to edit will result in two versions of the same file.
  7034.    The one that is written last will overwrite the other one, resulting in
  7035.    loss of changes.  The text "(still running)" indicates that the process
  7036.    editing this file runs on the same computer (Unix only).  When working over
  7037.    a network you will not see this message, because the process will be
  7038.    running on another computer.
  7039. 2. Recover a previously crashed edit session.  See below |recovery|.
  7040.  
  7041. Vim cannot always detect that a swap file already exists for a file.  This is
  7042. the case when the other edit session puts the swap files in another
  7043. directory or when the path name for the file is different when editing it on
  7044. different machines.
  7045.  
  7046. The swap file is updated after typing 200 characters or when you have not
  7047. typed anything for four seconds.  This only happens if the buffer was
  7048. changed, not when you only moved around.  The reason why it is not kept up to
  7049. date all the time is that this would slow down normal work too much.  You can
  7050. change the 200 character count with the 'updatecount' option.  You can set
  7051. the time with the 'updatetime' option.  The time is given in milliseconds.
  7052. After writing to the swap file Vim syncs the file to disk.  This takes some
  7053. time, especially on busy Unix systems.  If you don't want this you can set the
  7054. 'swapsync' option to an empty string.  The risk of loosing work becomes bigger
  7055. though.  On some non-Unix systems (MS-DOS, Amiga) the swap file won't be
  7056. written at all.
  7057.  
  7058. If the writing to the swap file is not wanted, it can be switched off by
  7059. setting the 'updatecount' option to 0.  The same is done when starting Vim
  7060. with the "-n" option.  Writing can be switched back on by setting the
  7061. 'updatecount' option to non-zero.  Swap files will be created for all buffers
  7062. when doing this.  But when setting 'updatecount' to zero, the existing swap
  7063. files will not be removed, it will only affect files that will be opened
  7064. after this.
  7065.  
  7066. If you want to make sure that your changes are in the swap file use this
  7067. command:
  7068.  
  7069.                             *:pre* *:preserve*
  7070. :pre[serve]        Write all text for all buffers into swap file.  The
  7071.             original file is no longer needed for recovery.  {Vi:
  7072.             emergency exit}
  7073.  
  7074. A Vim swap file can be recognized by the first six characters: "b0VIM ".
  7075. After that comes the version number, e.g., "3.0".
  7076.  
  7077.  
  7078. 18.2 Recovery                        *recovery*
  7079.  
  7080. In most cases recovery is quite easy: Start Vim on the same file you were
  7081. editing when the crash happened, with the "-r" option added.  Vim will read
  7082. the ".swp" file and may read bits and pieces of the original file.
  7083.  
  7084. Example:    vim -r vim_ref.txt
  7085.  
  7086. If you were editing without a file name, give an empty string as argument:
  7087.         vim -r ""
  7088.  
  7089. If there are several swap files that look they may be the one you want to
  7090. use, a list is given of these swap files and you are requested to enter the
  7091. number of the one you want to use.  In case you don't know which one to use,
  7092. just try them one by one and check the resulting files if they are what you
  7093. expected.
  7094.  
  7095. If you know which swap file needs to be used, you can recover by giving the
  7096. swap file name.  Vim will then find out the name of the original file from
  7097. the swap file.
  7098.  
  7099. Example:    Vim -r vim_ref.txt.swo
  7100.  
  7101. This is also handy when the swap file is in another directory than expected.
  7102. If this still does not work, see what file names Vim reports and rename the
  7103. files accordingly.  Check the 'directory' option to see where Vim may have
  7104. put the swap file.
  7105.  
  7106. Another way to do recovery is to start Vim and use the ":recover" command.
  7107. This is easy when you start Vim to edit a file and you get the "ATTENTION:
  7108. Found a swap file ..." message.  In this case the single command ":recover"
  7109. will do the work.  You can also give the name of the file or the swap file to
  7110. the recover command:
  7111.                             *:rec* *:recover*
  7112. :rec[over] [file]    Try to recover [file] from the swap file.  If [file]
  7113.             is not given use the file name for the current
  7114.             buffer.  The current contents of the buffer are lost.
  7115.             This command fails if the buffer was modified.
  7116.  
  7117. :rec[over]! [file]    Like ":recover", but any changes in the current
  7118.             buffer are lost.
  7119.  
  7120. Vim has some intelligence about what to do if the swap file is corrupt in
  7121. some way.  If Vim has doubt about what it found, it will give an error
  7122. message and insert lines with "???" in the text.  If you see an error message
  7123. while recovering, search in the file for "???" to see what is wrong.  You may
  7124. want to cut and paste to get the text you need.
  7125.  
  7126. Be sure that the recovery was successful before overwriting the original
  7127. file or deleting the swap file.  It is good practice to write the recovered
  7128. file elsewhere and run 'diff' to find out if the changes you want are in the
  7129. recovered file.
  7130.  
  7131. Once you are sure the recovery is ok delete the swap file.  Otherwise, you
  7132. will continue to get warning messages that the ".swp" file already exists.
  7133.  
  7134. {Vi: recovers in another way and sends mail if there is something to recover}
  7135.  
  7136.  
  7137. 19. Options                        *options*
  7138. ===========
  7139.  
  7140. Vi has a number of internal variables and switches which can be set to
  7141. achieve special effects.  These options come in three forms:
  7142.     toggle        can only be on or off        *toggle*
  7143.     number        has a numeric value
  7144.     string        has a string value
  7145.  
  7146. 19.1 Setting options                    *set_option*
  7147.  
  7148.                             *:se* *:set*
  7149. :se[t]            Show all options that differ from their default value.
  7150.  
  7151. :se[t] all        Show all but terminal options.
  7152.  
  7153. :se[t] termcap        Show all terminal options.
  7154.  
  7155. :se[t] {option}?    Show value of {option}.
  7156.  
  7157. :se[t] {option}        Toggle option: set, switch it on.
  7158.             Number option: show value.
  7159.             String option: show value.
  7160.  
  7161. :se[t] no{option}    Toggle option: Reset, switch it off.
  7162.  
  7163. :se[t] {option}!   or
  7164. :se[t] inv{option}    Toggle option: Invert value.  {not in Vi}
  7165.  
  7166. :se[t] {option}&    Reset option to its default value.  {not in Vi}
  7167.  
  7168. :se[t] {option}={value}        or
  7169. :se[t] {option}:{value}
  7170.             Set string or number option to {value}.  For numeric
  7171.             options the value can be given in decimal, hex
  7172.             (preceded with 0x) or octal (preceded with '0')
  7173.             (hex and octal are only available for machines which
  7174.             have the strtol() function).  The old value can be
  7175.             inserted by typing <Tab> (or whatever the value of
  7176.             'wildchar' is).  See 4.4.2 |cmdline_completion|.
  7177.             See |option_backslash| for using backslashes in
  7178.             {value}.
  7179.  
  7180.                             *:fix* *:fixdel*
  7181. :fix[del]        Set the value of 't_kD':
  7182.                 't_kb' is     't_kD' becomes
  7183.                   CTRL-?    CTRL-H
  7184.                 not CTRL-?    CTRL-?
  7185.  
  7186.             (CTRL-? is 0177 octal, 0x7f hex) {not in Vi}
  7187.  
  7188.             If your delete key terminal code is wrong, but the
  7189.             code for backspace is allright, you can put this in
  7190.             your .vimrc:
  7191.                 :fixdel
  7192.             This works no matter what the actual code for
  7193.             backspace is.
  7194.  
  7195.             If the backspace key terminal code is
  7196.             wrong you can use this:
  7197.                 :set t_kb=^V<BS>
  7198.                 :fixdel
  7199.             Where "^V" is CTRL-V and "<BS>" is the backspace
  7200.             key.  This will only work for terminals with the same
  7201.             code for the backspace key, you cannot use this in
  7202.             your .vimrc unless the code for backspace is the same
  7203.             on all your systems.
  7204.  
  7205.             If your <Delete> key sends a strange key sequence (not
  7206.             CTRL-? or CTRL-H) you cannot use ":fixdel".  Then use:
  7207.                 :set t_kD=^V<Delete>
  7208.             Where "^V" is CTRL-V and "<Delete>" is the delete key.
  7209.             This will only work on systems with the same terminal
  7210.             codes for delete.
  7211.  
  7212.             Note about Linux: By default the backspace key
  7213.             produces CTRL-?, which is wrong.  You can fix it by
  7214.             putting this line in your rc.local:
  7215.                 echo "keycode 14 = BackSpace" | loadkeys
  7216.  
  7217. The {option} arguments to ":set" may be repeated.  For example:
  7218.     ":set ai nosi sw=3 ts=3".
  7219. If you make an error in one of the arguments an error message will be given
  7220. and the text up to the next space will be skipped.  Thus following arguments
  7221. will be processed.
  7222.  
  7223. For {option} the form "t_xx" may be used to set a termcap option.  This will
  7224. override the value from the termcap.  You can then use it in a mapping.  If
  7225. the "xx" part contains special characters, use the <t_xx> form:
  7226.     :set <t_#4>=^[Ot
  7227.  
  7228. The listing from ":set" looks different from Vi.  Long string options are put
  7229. at the end of the list.  The number of options is quite large.  The output of
  7230. "set all" probably does not fit on the screen, causing Vim to give the
  7231. "--more--" message.  See the 'more' option.
  7232.  
  7233.                             *:set_env*
  7234. Environment variables in most string options will be expanded.  If the
  7235. environment variable exists the '$' and the following environment variable
  7236. name is replaced with its value.  If it does not exist the '$' and the name
  7237. are not modified.  Any non-id character (not a letter, digit or '_') may
  7238. follow the environment variable name.  That character and what follows is
  7239. appended to the value of the environment variable.  Examples:
  7240.     :set term=$TERM.new
  7241.     :set path=/usr/$INCLUDE,$HOME/include,.
  7242.  
  7243. Using "~" is like using "$HOME", but it is only recognized at the start of an
  7244. option and after a space or comma.
  7245.  
  7246.                             *option_backslash*
  7247. To include white space in a string option value it has to be preceded with a
  7248. backslash.  To include a backslash you have to use two.  Effectively this
  7249. means that the number of backslashes in an option value is halved (rounded
  7250. down).
  7251. A few examples:
  7252.     :set tags=tags\ /usr/tags     results in "tags /usr/tags"
  7253.     :set tags=tags\\,file        results in "tags\,file"
  7254.     :set tags=tags\\\ file        results in "tags\ file"
  7255.  
  7256. For MS-DOS and WIN32 backslashes in file names are mostly not removed.  More
  7257. precise: For options that expect a file name (those where environment
  7258. variables are expanded) a backslash before a normal file name character is not
  7259. removed.  But a backslash before a special character (space, backslash, comma,
  7260. etc.) is used like explained above.
  7261.  
  7262.  
  7263. 19.2 Automatically setting options            *auto_setting*
  7264.  
  7265. Besides changing options with the ":set" command, there are three alternatives
  7266. to set options automatically for one or more files:
  7267.  
  7268. 1. When starting Vim initializations are read from various places.  See
  7269.    |initialization|.  Most of them are performed for all editing sessions,
  7270.    and some of them depend on the directory where Vim is started.
  7271. 2. If you start editing a new file, the automatic commands are executed.
  7272.    This can be used to set options for files matching a particular pattern and
  7273.    many other things.  See the section "Automatic commands" |autocommand|.
  7274. 3. If you start editing a new file, and the 'modeline' option is on, a
  7275.    number of lines at the beginning and end of the file are checked for
  7276.    modelines.  This is explained here.
  7277.  
  7278.                             *modeline*
  7279. There are two forms of modelines.  The first form:
  7280.     [text]{white}{vi:|vim:|ex:}[white]{options}
  7281.  
  7282. [text]        any text or empty
  7283. {white}        at least one white space (<Space> or <Tab>)
  7284. {vi:|vim:|ex:}    the string "vi:", "vim:" or "ex:"
  7285. [white]        optional white space
  7286. {options}    a list of option settings, separated with white space or ':',
  7287.         where each part between ':' is the argument for a ":set"
  7288.         command
  7289.  
  7290. Example:
  7291.     " vi:noai:sw=3 ts=6"
  7292.  
  7293. The second form (this is compatible with some versions of Vi):
  7294.  
  7295.     [text]{white}{vi:|vim:|ex:}[white]set {options}:[text]
  7296.  
  7297. [text]        any text or empty
  7298. {white}        at least one white space (<Space> or <Tab>)
  7299. {vi:|vim:|ex:}    the string "vi:", "vim:" or "ex:"
  7300. [white]        optional white space
  7301. set         the string "set " (note the space)
  7302. {options}    a list of options, separated with white space, which is the
  7303.         argument for a ":set" command
  7304. :        a colon
  7305. [text]        any text or empty
  7306.  
  7307. Example:
  7308.     "/* vim: set ai tw=75: */"
  7309.  
  7310. The white space before {vi:|vim:|ex:} is required.  This minimizes the chance
  7311. that a normal word like "lex:" is caught.  There is one exception: "vi:" and
  7312. "vim:" can also be at the start of the line (for compatibility with version
  7313. 3.0).  Using "ex:" at the start of the line will be ignored (this could be
  7314. short for "example:").
  7315.  
  7316. The number of lines that are checked can be set with the 'modelines' option.
  7317. If 'modeline' is off or 'modelines' is 0 no lines are checked.
  7318.  
  7319. Note that for the first form all of the rest of the line is used, thus a line
  7320. like:
  7321.     "/* vi:ts=4: */"
  7322. will give an error message for the trailing "*/".  This line is OK:
  7323.     "/* vi:set ts=4: */"
  7324.  
  7325. If an error is detected the rest of the line is skipped.
  7326.  
  7327. If you want to include a ':' in a set command precede it with a '\'.  No other
  7328. commands than "set" are supported, for security reasons (somebody might create
  7329. a trojan horse text file with modelines).
  7330.  
  7331.  
  7332. 19.3 Saving settings                    *save_settings*
  7333.  
  7334.                             *:mk* *:mkexrc*
  7335. :mk[exrc] [file]    Write current key mappings and changed options to
  7336.             [file] (default ".exrc" in the current directory),
  7337.             unless it already exists.  {not in Vi}
  7338.  
  7339. :mk[exrc]! [file]    Always write current key mappings and changed
  7340.             options to [file] (default ".exrc" in the current
  7341.             directory).  {not in Vi}
  7342.  
  7343.                             *:mkv* *:mkvimrc*
  7344. :mkv[imrc][!] [file]    Like as :mkexrc, but default is ".vimrc" in the
  7345.             current directory.  The ":version" command is also
  7346.             written to the file.  {not in Vi}
  7347.  
  7348. These commands will write ":map" and ":set" commands to a file, in such a way
  7349. that when these commands are executed, the current key mappings and options
  7350. will be set to the same values.  The options 'columns', 'endofline', 'lines',
  7351. 'modified', 'scroll', 'term' and 'ttyfast' are not included, because these are
  7352. terminal or file dependent.  Note that the options 'binary', 'textmode',
  7353. 'paste' and 'readonly' are included, this might not always be what you want.
  7354.  
  7355. A common method is to use a default ".vimrc" file, make some modifications
  7356. with ":map" and ":set" commands and write the modified file.  First read the
  7357. default ".vimrc" in with a command like ":source ~piet/.vimrc.Cprogs", change
  7358. the settings and then save them in the current directory with ":mkvimrc!".  If
  7359. you want to make this file your default .vimrc, move it to your home directory
  7360. (on Unix), s: (Amiga) or $VIM directory (MS-DOS).  You could also use
  7361. autocommands |autocommand| and/or modelines |modeline|.
  7362.  
  7363.  
  7364. 19.4 Options summary                *option_summary*
  7365.  
  7366. In the list below all the options are mentioned with their full name and some
  7367. with an abbreviation between parens.  Both forms may be used.  In this
  7368. document when an option that can be toggled is "set" that means that ":set
  7369. option" is entered.  When an option is "reset", ":set nooption" is used.
  7370.  
  7371. Most options are the same in all windows and buffers.  There are a few that
  7372. are specific to how the text is presented in a window.  These can be set to a
  7373. different value in each window.  For example the 'list' option can be set in
  7374. one window and reset in another for the same text, giving both types of view
  7375. at the same time.  There are a few options that are specific to a certain
  7376. file.  These can have a different value for each file or buffer.  For example
  7377. the 'textwith' option can be 78 for a normal text file and 0 for a C
  7378. program.
  7379.  
  7380.     global            one option for all buffers and windows
  7381.     local to window        each window has its own copy of this option
  7382.     local to buffer        each buffer has its own copy of this option
  7383.  
  7384. When creating a new window the option values from the currently active window
  7385. are used as a default value for the window-specific options.  For the
  7386. buffer-specific options this depends on the 's' and 'S' flags in the
  7387. 'cpoptions' option.  If 's' in included (which is the default) the values for
  7388. buffer options are copied from the currently active buffer when a buffer is
  7389. first entered.  If 'S' is present the options are copied each time the buffer
  7390. is entered, this is almost like having global options.  If 's' and 'S' are not
  7391. present, the options are copied from the currently active buffer when the
  7392. buffer is created.
  7393.  
  7394. A jump table for the options with a short description can be found at |X_op|.
  7395.  
  7396.                     *'aleph'* *'al'*
  7397. aleph (al)        number  (default 128 for MS-DOS, 224 otherwise)
  7398.             global
  7399.             {not in Vi}
  7400.             {This option applies only if Vim was compiled with
  7401.             RIGHTLEFT defined}
  7402.     The ASCII code for the first letter of the Hebrew alphabet.  The
  7403.     routine that maps the keyboard in Hebrew mode, both in Insert mode
  7404.     (when hkmap is set) and on the command line (when hitting CTRL-_)
  7405.     outputs the Hebrew characters in the range [aleph..aleph+26].
  7406.     aleph=128 applies to PC code, and aleph=224 applies to ISO 8859-8.
  7407.     See |vim_rlh.txt|.
  7408.  
  7409.                    *'autoindent'* *'ai'* *'noautoindent'* *'noai'*
  7410. autoindent (ai)        toggle    (default off)
  7411.             local to buffer
  7412.     Copy indent from current line when starting a new line (typing <CR>
  7413.     in Insert mode or when using the "o" or "O" command).  If you do not
  7414.     type anything on the new line except <BS> and then type <Esc> or
  7415.     <CR>, the indent is deleted again.  When autoindent is on,
  7416.     formatting (with the "gq" command or when you reach 'textwidth' in
  7417.     Insert mode) uses the indentation of the first line.   When
  7418.     'smartindent' or 'cindent' is on the indent is changed in specific
  7419.     cases.  The 'autoindent' option is reset when the 'paste' option is
  7420.     set.  {small difference from Vi: After the indent is deleted when
  7421.     typing <Esc> or <CR>, the cursor position when moving up or down is
  7422.     after the deleted indent; Vi puts the cursor somewhere in the deleted
  7423.     indent}.
  7424.  
  7425.                  *'autowrite'* *'aw'* *'noautowrite'* *'noaw'*
  7426. autowrite (aw)        toggle    (default off)
  7427.             global
  7428.     Write the contents of the file, if it has been modified, on each
  7429.     :next, :rewind, :previous, :stop, :suspend, :tag, :!, :make, CTRL-]
  7430.     and CTRL-^ command; and when a CTRL-O, CTRL-I, '<A-Z0-9>, or `<A-Z0-9>
  7431.     command takes one to another file.
  7432.  
  7433.                     *'backspace'* *'bs'*
  7434. backspace (bs)        number    (default 0)
  7435.             global
  7436.             {not in Vi}
  7437.     Influences the working of <BS>, <Del>, CTRL-W and CTRL-U in Insert
  7438.     mode.  If set to 0 Vi compatible backspacing is used.  When 1 allow
  7439.     backspacing over newlines.  When larger than 1 allow backspacing over
  7440.     the start of insert.  In the last case CTRL-W and CTRL-U stop once at
  7441.     the start of insert.  See |:fixdel| if your <BS> or <Del> key does not
  7442.     do what you want.
  7443.  
  7444.                        *'backup'* *'bk'* *'nobackup'* *'nobk'*
  7445. backup (bk)        toggle    (default off)
  7446.             global
  7447.             {not in Vi}
  7448.     Make a backup before overwriting a file.  Leave it around after the
  7449.     file has been successfully written.  If you do not want to keep the
  7450.     backup file, but you do want a backup while the file is being
  7451.     written, reset this option and set the 'writebackup' option (this is
  7452.     the default).  If you do not want a backup file at all reset both
  7453.     options (use this if your file system is almost full).  See the table
  7454.     in section 5.4 for more explanations |backup_table|.
  7455.  
  7456.                         *'backupdir'* *'bdir'*
  7457. backupdir (bdir)    string    (default for Amiga: ".,t:",
  7458.                  for MS-DOS and Win32: ".,c:/tmp,c:/temp"
  7459.                  for Unix: ".,~/tmp,~/")
  7460.             global
  7461.             {not in Vi}
  7462.     List of directories for the backup file, separated with commas.
  7463.     - The backup file will be created in the first directory in the list
  7464.       where this is possible.
  7465.     - Empty means that no backup file will be created ('patchmode' is
  7466.       impossible!).
  7467.     - A directory '.' means to put the backup file in the same directory
  7468.       as the edited file.  Characters after the "." are ignored, "./temp"
  7469.       is handled in the same way as ".".
  7470.     - Spaces after the comma are ignored, other spaces are considered part
  7471.       of the directory name.  To have a space at the start of a directory
  7472.       name, precede it with a backslash.
  7473.     - To include a comma in a directory name precede it with a backslash.
  7474.     - A directory name may end in an '/'.
  7475.     - Environment variables are expanded |:set_env|.
  7476.     - Careful with '\' characters, type one before a space, type two to
  7477.       get one in the option (see |option_backslash|), for example:
  7478.         :set bdir=c:\\tmp,\ dir\\,with\\,commas,\\\ dir\ with\ spaces
  7479.     - For backwards compatibility with Vim version 3.0 a '>' at the start
  7480.       of the option is removed.
  7481.     See also 'backup' and 'writebackup' options.
  7482.  
  7483.                         *'backupext'* *'bex'*
  7484. backupext (bex)        string    (default "~")
  7485.             global
  7486.             {not in Vi}
  7487.     String which is appended to a file name to make the name of the
  7488.     backup file.  The default is quite unusual, because this avoids
  7489.     accidently overwriting existing files with a backup file.  You might
  7490.     prefer using ".bak", but make sure that you don't have files with
  7491.     ".bak" that you want to keep.
  7492.  
  7493.                      *'binary'* *'bin'* *'nobinary'* *'nobin'*
  7494. binary (bin)        toggle    (default off)
  7495.             local to buffer
  7496.             {not in Vi}
  7497.     This option should be set before editing a binary file.  You can also
  7498.     use the "-b" Vim argument.  When this option is switched on a few
  7499.     options will be changed (also when it already was on):
  7500.         'textwidth'  will be set to 0
  7501.         'wrapmargin' will be set to 0
  7502.         'modeline'   will be off
  7503.         'textmode'   will be off
  7504.         'textauto'   will be off
  7505.         'expandtab'  will be off
  7506.     NOTE: When you start editing a(nother) file while the 'bin' option is
  7507.     on, settings from the modelines or autocommands may change the
  7508.     settings again (e.g., 'textwidth'), causing trouble when editing.  You
  7509.     might want to set 'bin' again when the file has been loaded.
  7510.     The previous values of these options are remembered and restored when
  7511.     'bin' is switched fron on to off.  Each buffer has its own set of
  7512.     saved option values, except for 'textauto', which is global.
  7513.     When writing a file the end-of-line for the last line is only written
  7514.     if there was one in the original file (normally Vim appends an
  7515.     end-of-line to the last line if there is none; this would make the
  7516.     file longer).  See the 'endofline' option.
  7517.  
  7518.                    *'bioskey'* *'biosk'* *'nobioskey'* *'nobiosk'*
  7519. bioskey (biosk)        toggle    (default on)
  7520.             global
  7521.             {not in Vi}  {Only for MS-DOS}
  7522.     When on the bios is called to obtain a keyboard character.  This works
  7523.     better to detect CTRL-C, but only works for the console.  When using a
  7524.     terminal over a serial port reset this option.
  7525.  
  7526.                         *'breakat'* *'brk'*
  7527. breakat (brk)        string    (default " ^I!@*-+_;:,./?")
  7528.             global
  7529.             {not in Vi}
  7530.     This option lets you choose which characters might cause a line
  7531.     break if 'linebreak' is on.
  7532.  
  7533.                    *'cindent'* *'cin'* *'nocindent'* *'nocin'*
  7534. cindent (cin)        toggle    (default off)
  7535.             local to buffer
  7536.             {not in Vi}
  7537.             {Only present when compiled with CINDENT enabled,
  7538.             ":version" says "+cindent" instead of "-cindent"}
  7539.     Enables automatic C program indenting  See 'cinkeys' to set the keys
  7540.     that trigger reindenting in insert mode and 'cinoptions' to set your
  7541.     preferred indent style.  If 'lisp' is not on and 'equalprg' is empty,
  7542.     the "=" operator indents using this algorithm rather than calling an
  7543.     external program.  See |C_indenting|.  This option is switched off
  7544.     when 'paste' is set.  When you don't like the way 'cindent' works, try
  7545.     the 'smartindent' option.
  7546.  
  7547. cinkeys (cink)        string    (default "0{,0},:,0#,!^F,o,O,e")
  7548.             local to buffer
  7549.             {not in Vi}
  7550.             {Only present when compiled with CINDENT enabled}
  7551.     A list of keys that, when typed in insert mode, cause reindenting of
  7552.     the current line.  Only happens if 'cindent' is on.  See
  7553.     |C_indenting|.
  7554.  
  7555.                         *'cinoptions'* *'cino'*
  7556. cinoptions (cino)    string    (default "")
  7557.             local to buffer
  7558.             {not in Vi}
  7559.             {Only present when compiled with CINDENT enabled}
  7560.     The 'cinoptions' affect the way 'cindent' reindents lines in a C
  7561.     program.  See |C_indenting|.
  7562.  
  7563.                         *'cinwords'* *'cinw'*
  7564. cinwords (cinw)        string    (default "if,else,while,do,for,switch")
  7565.             local to buffer
  7566.             {not in Vi}
  7567.             {Only present when compiled with CINDENT or
  7568.             SMARTINDENT enabled}
  7569.     These keywords start an extra indent in the next line when
  7570.     'smartindent' or 'cindent' is set.  For 'cindent' this is only done at
  7571.     an appropriate place (inside {}).
  7572.  
  7573.                         *'cmdheight'* *'ch'*
  7574. cmdheight (ch)        number    (default 1)
  7575.             global
  7576.             {not in Vi}
  7577.     Number of lines to use for the command line.  If you are annoyed by
  7578.     "Hit return ..." caused by long messages, set this option to a larger
  7579.     value.
  7580.  
  7581.                         *'columns'* *'co'*
  7582. columns (co)        number    (default 80 or terminal width)
  7583.             global
  7584.             {not in Vi}
  7585.     Number of columns of the screen.  Normally this is set by the terminal
  7586.     initialization and does not have to be set by hand.
  7587.  
  7588.                         *'comments'* *'com'*
  7589. comments (com)        string    (default
  7590.                 "sr:/*,mb:*,el:*/,://,b:#,:%,:XCOMM,n:>,fb:-")
  7591.             local to buffer
  7592.             {not in Vi}
  7593.     A comma separated list of patterns that can start a comment line.  See
  7594.     |format_comments|.  See |option_backslash| about using backslashes to
  7595.     insert a space.
  7596.  
  7597.                    *'compatible'* *'cp'* *'nocompatible'* *'nocp'*
  7598. compatible (cp)        toggle    (default off, on when compiled with COMPATIBLE
  7599.                 defined, ":version" shows "+compatible")
  7600.             global
  7601.             {not in Vi}
  7602.     At the moment this option is set, several other options will be set
  7603.     or reset to make Vim Vi-compatible.  Switching this option off has no
  7604.     effect.  See also 'cpoptions'.
  7605.  
  7606.     option        new value    effect
  7607.  
  7608.     backspace    0        normal backspace
  7609.     backup        off        no backup file
  7610.     cindent        off        no C code indentation
  7611.     cpoptions    "bcefFkmorsStx$!%"    vi-compatible flags
  7612.     digraph        off        no digraphs
  7613.     esckeys        off        no <Esc>-keys in Insert mode
  7614.     expandtab    off        tabs not expanded to spaces
  7615.     formatoptions    "vt"        Vi compatible formatting
  7616.     gdefault    off        no default 'g' flag for ":s"
  7617.     history        0        no commandline history
  7618.     insertmode    off        do not start in Insert mode
  7619.     iskeyword    "@,48-57,_"    keywords contain alphanumeric
  7620.                         characters and '_'
  7621.     joinspaces    on        insert 2 spaces after period
  7622.     modeline    off        no modelines
  7623.     more        off        no pauses in listings
  7624.     revins        off        no reverse insert
  7625.     ruler        off        no ruler
  7626.     scrolljump    1        no jump scroll
  7627.     scrolloff    0        no scroll offset
  7628.     shiftround    off        indent not rounded to shiftwidth
  7629.     showcmd        off        command characters not shown
  7630.     showmode    off        current mode not shown
  7631.     smartcase    off        no automatic ignore case switch
  7632.     smartindent    off        no smart indentation
  7633.     smarttab    off        no smart tab size
  7634.     startofline    on        goto startofline with some commands
  7635.     textauto    off        no automatic textmode detection
  7636.     textwidth    0        no automatic line wrap
  7637.     tildeop        off        tilde is not an operator
  7638.     ttimeout    off        no terminal timeout
  7639.     undolevels    0        no multilevel undo
  7640.     updatecount    0        no swap file
  7641.     whichwrap    ""        left-right movements don't wrap
  7642.     wildchar    CTRL-E        only when the current value is <Tab>
  7643.                     use CTRL-E for cmdline completion
  7644.     writebackup    off        no backup file written
  7645.  
  7646.                         *'cpoptions'* *'cpo'*
  7647. cpoptions (cpo)        string    (default "BceFs", unless compiled with
  7648.                 COMPATIBLE defined, then all flags are
  7649.                 included)
  7650.             global
  7651.             {not in Vi}
  7652.     Sequence of characters.  When a character is present this indicates
  7653.     vi-compatible behaviour.  This is used for things where not being
  7654.     vi-compatible is mostly or sometimes preferred.  'cpoptions' stands
  7655.     for 'compatibleoptions'.  Commas can be added for readability.
  7656.  
  7657.         contains    behaviour
  7658.         b    "\|" in a ":map" command is recognized as the end of
  7659.             the map command.  The '\' is included in the mapping,
  7660.             the text after the '|' is interpreted as the next
  7661.             command.  Use a CTRL-V instead of a backslash to
  7662.             include the '|' in the mapping.  Applies to all
  7663.             mapping, abbreviation, menu and autocmd commands.
  7664.             See also |map_bar|.
  7665.         B    A backslash has no special meaning in mappings,
  7666.             abbreviations and the "to" part of the menu commands.
  7667.             Remove this flag to be able to use a backslash like a
  7668.             CTRL-V.  This flag must be removed to be able to fully
  7669.             use the <> notation.  For example, the command
  7670.             ":map X \<Esc>" results in X being mapped to:
  7671.                 'B' included:    "\^["    (^[ is a real <Esc>)
  7672.                 'B' excluded:   "<Esc>"  (5 characters)
  7673.                 ('<' excluded in both cases)
  7674.         <    Disable the recognition of special key codes in <>
  7675.             form in mappings, abbreviations, and the "to" part of
  7676.             menu commands.  For example, the command
  7677.             ":map X <Tab>" results in X being mapped to:
  7678.                 '<' included:   "<Tab>"  (5 characters)
  7679.                 '<' excluded:   "^I"     (^I is a real <Tab>)
  7680.             Also see the 'k' flag below.
  7681.         c    Searching continues at the end of any match at the
  7682.             cursor position.  When not present searching continues
  7683.             one character from the cursor position.  With 'c'
  7684.             "abababababab" only gets three matches when repeating
  7685.             "/abab", without 'c' there are five matches.
  7686.         e    When executing a register with ":@r", always add a
  7687.             <CR> to the last line, also when the register is not
  7688.             linewise.  If this flag is not present, the register
  7689.             is not linewise and the last line does not end in a
  7690.             <CR>, then the last line is put on the command line
  7691.             and can be edited before hitting <CR>.
  7692.         f    When included, a ":read" command with a file name
  7693.             argument will set the file name for the current buffer,
  7694.             if the current buffer doesn't have a file name yet.
  7695.         F    When included, a ":write" command with a file name
  7696.             argument will set the file name for the current buffer,
  7697.             if the current buffer doesn't have a file name yet.
  7698.         k    Disable the recognition of raw key codes in
  7699.             mappings, abbreviations, and the "to" part of menu
  7700.             commands.  For example, if <Key> sends ^[OA (where ^[
  7701.             is <Esc>), the command ":map X ^[OA" results in X
  7702.             being mapped to:
  7703.                 'k' included:   "^[OA"   (3 characters)
  7704.                 'k' excluded:   "<Key>"  (one key code)
  7705.             Also see the '<' flag above.
  7706.         m    When included, a showmatch will always wait half a
  7707.             second.  When not included, a showmatch will wait half
  7708.             a second or until a character is typed.  |'showmatch'|
  7709.         o    Line offset to search command is not remembered for
  7710.             next search.
  7711.         r    Redo ("." command) uses "/" to repeat a search
  7712.             command, instead of the actually used search string.
  7713.         s    Set buffer options when entering the buffer for the
  7714.             first time.  This is like it is in Vim version 3.0.
  7715.             And it is the default.  If not present the options are
  7716.             set when the buffer is created.
  7717.         S    Set buffer options always when entering a buffer
  7718.             (except 'readonly' and 'textmode').  This is the
  7719.             (most) vi compatible setting.
  7720.             The options are set to the values in the current
  7721.             buffer.  When you change an option and go to another
  7722.             buffer, the value is copied.  Effectively makes the
  7723.             buffer options global to all buffers.
  7724.  
  7725.             's'    'S'     copy buffer options
  7726.             no     no      when buffer created
  7727.             yes    no      when buffer first entered (default)
  7728.             no     yes     each time when buffer entered (vi comp.)
  7729.             yes    yes     when buffer created or first entered
  7730.  
  7731.         t    Search pattern for the tag command is remembered for
  7732.             "n" command.  Otherwise Vim only puts the pattern in
  7733.             the history for search pattern, but doesn't change the
  7734.             last used search pattern.
  7735.         x    <Esc> on the command line executes the command line.
  7736.             The default in Vim is to abandon the command line,
  7737.             because <Esc> normally aborts a command.  |c_<Esc>|
  7738.         $    When making a change to one line, don't redisplay the
  7739.             line, but put a '$' at the end of the changed text.
  7740.             The changed text will be overwritten when you type the
  7741.             new text.  The line is redisplayed if you type any
  7742.             command that moves the cursor from the insertion
  7743.             point.
  7744.         !    When redoing a filter command, use the last used
  7745.             external command, whatever it was.  Otherwise the last
  7746.             used -filter- command is used.
  7747.         %    Vi-compatible matching is done for the "%" command.
  7748.             Parens inside single and double quotes are also
  7749.             counted, causing a string that contains a paren to
  7750.             disturb the matching.  For example, in a line like
  7751.             "if (strcmp("foo(", s))" the first paren does not
  7752.             match the last one.  When this flag is not included,
  7753.             parens inside single and double quotes are treated
  7754.             specially.  When matching a paren outside of quotes,
  7755.             everyting inside quotes is ignored.  When matching a
  7756.             paren inside quotes, it will find the matching one (if
  7757.             there is one).  This works very well for C programs.
  7758.  
  7759.                         *'define'* *'def'*
  7760. define (def)        string    (default "^#[ \t]*define")
  7761.             global
  7762.             {not in Vi}
  7763.     Pattern to be used to find a macro definition.  It is a search
  7764.     pattern, just like for the "/" command.  The default value is for C
  7765.     programs.  This option is used for the commands like "[i" and "[d"
  7766.     |include_search|.  The 'isident' option is used to recognize the
  7767.     identifier name after the match.  See |option_backslash| about
  7768.     inserting backslashes to include a space or backslash.
  7769.  
  7770.                         *'dictionary'* *'dict'*
  7771. dictionary (dict)    string    (default "")
  7772.             global
  7773.             {not in Vi}
  7774.     List of file names, separated by commas, that are used to lookup words
  7775.     for keyword completion commands |i_CTRL-X_CTRL-K|.  Each file should
  7776.     contain a list of words, one word per line.  To include a comma in a
  7777.     file name precede it with a backslash.  Spaces after a comma are
  7778.     ignored, otherwise spaces are included in the file name.  See
  7779.     |option_backslash| about using backslashes.
  7780.  
  7781.                      *'digraph'* *'dg'* *'nodigraph'* *'nodg'*
  7782. digraph (dg)        toggle    (default off)
  7783.             global
  7784.             {not in Vi}
  7785.             {Only applies when compiled with DIGRAPHS defined,
  7786.             check with ":version"}
  7787.     Enable the entering of digraphs in Insert mode with {char1} <BS>
  7788.     {char2}.  See |digraphs|.
  7789.  
  7790.                         *'directory'* *'dir'*
  7791. directory (dir)        string    (default for Amiga: ".,t:",
  7792.                  for MS-DOS and Win32: ".,c:\tmp,c:\temp"
  7793.                  for Unix: ".,~/tmp,/tmp")
  7794.             global
  7795.     List of directory names for the swap file, separated with commas.
  7796.     - The swap file will be created in the first directory where this is
  7797.       possible.
  7798.     - Empty means that no swap file will be used (recovery is
  7799.       impossible!).
  7800.     - A directory '.' means to put the swap file in the same directory as
  7801.       the edited file.  Everything after the "." is ignored, "./temp" is
  7802.       handled in the same way as ".".
  7803.     - Spaces after the comma are ignored, other spaces are considered part
  7804.       of the directory name.  To have a space at the start of a directory
  7805.       name, precede it with a backslash.
  7806.     - To include a comma in a directory name precede it with a backslash.
  7807.     - A directory name may end in an ':' or '/'.
  7808.     - Environment variables are expanded |:set_env|.
  7809.     - Careful with '\' characters, type one before a space, type two to
  7810.       get one in the option (see |option_backslash|), for example:
  7811.         :set dir=c:\\tmp,\ dir\\,with\\,commas,\\\ dir\ with\ spaces
  7812.     - For backwards compatibility with Vim version 3.0 a '>' at the start
  7813.       of the option is removed.
  7814.     Using "." first in the list is recommended.  This means that editing
  7815.     the same file twice will result in a warning.  Using "/tmp" on Unix is
  7816.     discouraged, when the system crashes you lose the swap file.  That is
  7817.     why a "tmp" directory in your home directory is used first.
  7818.     {Vi: directory to put temp file in, defaults to "/tmp"}
  7819.  
  7820.                *'ed'* *'edcompatible'* *'noed'* *'noedcompatible'*
  7821. edcompatible (ed)    toggle    (default off)
  7822.             global
  7823.     Makes the 'g' and 'c' flags of the ":substitute" command to be
  7824.     toggled each time the flag is given.  See 11.3 |complex_change|.  See
  7825.     also 'gdefault' option.
  7826.  
  7827.                    *'endofline'* *'eol'* *'noendofline'* *'noeol'*
  7828. endofline (eol)        toggle    (default on)
  7829.             local to buffer
  7830.             {not in Vi}
  7831.     When writing a file and this option is off and the 'binary' option
  7832.     is on, no end of line (newline) character will be written for the
  7833.     last line in the file.  This option is automatically set when
  7834.     starting to edit a new file, unless the file does not have an end of
  7835.     line (newline) for the last line in the file, in which case it is
  7836.     reset.  Normally you don't have to set or reset this option.  When
  7837.     'binary' is off the value is not used when writing the file.  When
  7838.     'binary' is on it is used to remember the presence of a newline for
  7839.     the last line in the file, so that when you write the file the
  7840.     situation from the original file can be kept.  But you can change it
  7841.     when you want to.
  7842.  
  7843.                  *'equalalways'* *'ea'* *'noequalalways'* *'noea'*
  7844. equalalways (ea)    toggle    (default on)
  7845.             global
  7846.             {not in Vi}
  7847.     When on all the windows are automatically made the same size after
  7848.     splitting or closing a window.  When off, splitting a window will
  7849.     reduce the size of the current window and leave the other windows the
  7850.     same.  When closing a window the extra lines are given the the window
  7851.     above it.
  7852.  
  7853.                         *'equalprg'* *'ep'*
  7854. equalprg (ep)        string    (default "")
  7855.             global
  7856.             {not in Vi}
  7857.     External program to use for "=" command.  When this option is empty
  7858.     the internal formatting functions are used ('lisp' or 'cindent').
  7859.     Environment variables are expanded |:set_env|.  See |option_backslash|
  7860.     about including spaces and backslashes.
  7861.  
  7862.                    *'errorbells'* *'eb'* *'noerrorbells'* *'noeb'*
  7863. errorbells (eb)        toggle    (default off)
  7864.             global
  7865.     Ring the bell (beep or screen flash) for error messages.  This only
  7866.     makes a difference for error messages, the bell will be used always
  7867.     for a lot of errors without a message (e.g., hitting <Esc> in Normal
  7868.     mode).  See 'visualbell' on how to make the bell behave like a beep,
  7869.     screen flash or do nothing.
  7870.  
  7871.                         *'errorfile'* *'ef'*
  7872. errorfile (ef)        string    (default "AztecC.Err" or "errors.vim")
  7873.             global
  7874.             {not in Vi}
  7875.     Name of the error file for the QuickFix mode (see 5.5
  7876.     |:make_makeprg|).  Environment variables are expanded |:set_env|.  See
  7877.     |option_backslash| about including spaces and backslashes.
  7878.  
  7879.                         *'errorformat'* *'efm'*
  7880. errorformat (efm)    string    (default is very long)
  7881.             global
  7882.             {not in Vi}
  7883.     Scanf-like description of the format for the lines in the error file
  7884.     (see 5.5 |errorformat|).
  7885.  
  7886.                      *'esckeys'* *'ek'* *'noesckeys'* *'noek'*
  7887. esckeys (ek)        toggle    (default on, off when compiled with COMPATIBLE
  7888.                 defined)
  7889.             global
  7890.             {not in Vi}
  7891.     Function keys that start with an <Esc> are recognized in Insert
  7892.     mode.  When this option is off, the cursor and function keys cannot be
  7893.     used in Insert mode if they start with an <Esc>.  The advantage of
  7894.     this is that the single <Esc> is recognized immediately, instead of
  7895.     after one second.  Instead of resetting this option, you might want to
  7896.     try changing the values for 'timeoutlen' and 'ttimeoutlen'.
  7897.  
  7898.                  *'expandtab'* *'et'* *'noexpandtab'* *'noet'*
  7899. expandtab (et)        toggle    (default off)
  7900.             local to buffer
  7901.             {not in Vi}
  7902.     In Insert mode: Use the appropriate number of spaces to insert a
  7903.     <Tab>.  Spaces are used in indents with the '>' and '<' commands and
  7904.     when 'autoindent' is on.  To insert a real tab when 'expandtab' is
  7905.     on, use CTRL-V<Tab>.  See also ":retab" command in 11.3 |:retab|
  7906.     and section 4.3.4 |ins_expandtab|.
  7907.  
  7908.                         *'exrc'* *'noexrc'*
  7909. exrc            toggle (default off)
  7910.             global
  7911.             {not in Vi}
  7912.     Enables the reading of .vimrc and .exrc in the current directory.  If
  7913.     you switch this option on you should also consider setting the
  7914.     'secure' option (see 3.4 |initialization|).  Using a local .exrc or
  7915.     .vimrc is a potential security leak, use with care!
  7916.  
  7917.                     *'formatoptions'* *'fo'*
  7918. formatoptions (fo)    string (default "tcq", "vt" when compiled with
  7919.                 COMPATIBLE defined)
  7920.             local to buffer
  7921.             {not in Vi}
  7922.     This is a sequence of letters which describes how automatic
  7923.     formatting is to be done.  See |fo_table|.  When the 'paste' option is
  7924.     on, no formatting is done (like 'formatoptions' is empty).  Commas can
  7925.     be inserted for readability.
  7926.  
  7927.                         *'formatprg'* *'fp'*
  7928. formatprg (fp)        string (default "")
  7929.             global
  7930.             {not in Vi}
  7931.     The name of an external program that will be used to format the lines
  7932.     selected with the "gq" command.  The program must take the input on
  7933.     stdin and produce the output on stdout.  The Unix program 'fmt' is
  7934.     such a program.  If this option is an empty string, the internal
  7935.     format function will be used |C_indenting|.  Environment variables are
  7936.     expanded |:set_env|.  See |option_backslash| about including spaces
  7937.     and backslashes.
  7938.  
  7939.                    *'gdefault'* *'gd'* *'nogdefault'* *'nogd'*
  7940. gdefault (gd)        toggle    (default off)
  7941.             global
  7942.             {not in Vi}
  7943.     When on, the ":substitute" flag 'g' is default on.  This means that
  7944.     all matches in a line are substituted instead of one.  When a 'g' flag
  7945.     is given to a ":substitute" command, this will toggle the substitution
  7946.     of all or one match.  See 11.3 |complex_change|.
  7947.  
  7948.         command        'gdefault' on    'gdefault' off
  7949.         :s///          subst. all      subst. one
  7950.         :s///g          subst. one      subst. all
  7951.         :s///gg          subst. all      subst. one
  7952.  
  7953.                         *'guifont'* *'gfn'*
  7954. guifont (gfn)        string  (default "")
  7955.             global
  7956.             {not in Vi}
  7957.             {Only available when compiled with GUI enabled}
  7958.     This is a list of fonts which should be tried when starting the GUI
  7959.     version of vim.  The fonts are separated with commas.  Spaces after a
  7960.     comma are ignored.  To include a comma in a font name precede it with
  7961.     a backslash.  Setting an option requires an extra backslash before a
  7962.     space and a backslash.  See also |option_backslash|.  For example:
  7963.         :set guifont=Screen15,\ 7x13,font\\,with\\,commas
  7964.     will make vim try to use the font "Screen15" first, and if it fails
  7965.     it will try to use "7x13" and then "font,with,commas" instead.  If
  7966.     none of the fonts can be loaded, vim will try using other resource
  7967.     settings (for X, it will use the Vim.font resource), and finally it
  7968.     will try some builtin default which should always be there ("7x13" in
  7969.     the case of X).  The font names given should be "normal" fonts.  Vim
  7970.     will try to find the related bold and italic fonts.
  7971.  
  7972.                         *'guioptions'* *'go'*
  7973. guioptions (go)        string  (default "agmr")
  7974.             global
  7975.             {not in Vi}
  7976.             {Only available when compiled with GUI enabled}
  7977.     This option only has an effect in the GUI version of vim.  It is a
  7978.     sequence of letters which describes what components and options of the
  7979.     GUI should be used.  Valid letters are as follows:
  7980.  
  7981.       'a'    Autoselect:  If present, then whenever VISUAL mode is started,
  7982.         or the Visual area extended, vim tries to become the owner of
  7983.         the windowing system's global selection.  This means that the
  7984.         Visually highlighted text is available for pasting into other
  7985.         applications as well as into vim itself.  When the Visual mode
  7986.         ends, possibly due to an operation on the text, or when an
  7987.         application wants to paste the selection, the highlighted text
  7988.         is automatically yanked into the <"*> GUI selection register.
  7989.         Thus the selection is still available for pasting into other
  7990.         applications after the VISUAL mode has ended.
  7991.             If not present, then vim won't become the owner of the
  7992.         windowing system's global selection unless explicitly told to
  7993.         by selecting "Cut" or "Copy" etc from the "Edit" menu (which
  7994.         have not been implemented yet!).
  7995.  
  7996.       'f'    Foreground: Don't use fork() to detatch the GUI from the shell
  7997.         where it was started.  Use this for programs that wait for the
  7998.         editor to finish (e.g., an e-mail program).  Altenatively you
  7999.         can use "gvim -f" or ":gui -f" to start the GUI in the
  8000.         foreground.  |gui_fork|
  8001.  
  8002.       'm'    Menu bar is present when 'm' is included.
  8003.       'g'    Grey menu items: Make menu items that are not active grey.  If
  8004.         'g' is not included inactive menu items are not shown at all.
  8005.  
  8006.       'r'    Right-hand scrollbar is present when 'r' is included.
  8007.       'l'    Left-hand scrollbar is present when 'l' is included.
  8008.       'b'    Bottom (horizontal) scrollbar is present when 'b' is included.
  8009.  
  8010.     And yes, you may even have scrollbars on the left AND the right if
  8011.     you really want to :-).  See |gui_scrollbars| for more information.
  8012.  
  8013.                         *'guipty'* *'noguipty'*
  8014. guipty            toggle    (default off)
  8015.             global
  8016.             {not in Vi}
  8017.             {Only available when compiled with GUI enabled}
  8018.     Only in the GUI: If on, an attempt is made to open a pseudo-tty for
  8019.     I/O to/from shell commands.  See |gui_pty|.
  8020.  
  8021.                     *'helpfile'* *'hf'*
  8022. helpfile (hf)        string    (default (Amiga) "vim:vim_help.txt"
  8023.                  (MS-DOS, Win32, OS/2) "$VIM/vim_help.txt"
  8024.                  (Unix) "/usr/local/lib/vim/vim_help.txt")
  8025.             global
  8026.             {not in Vi}
  8027.     Name of the help file.  All help files should be placed together in
  8028.     one directory.  Environment variables are expanded |:set_env|.  For
  8029.     example: "$VIM/doc/vim_help.txt".  If $VIM is not set, $HOME is also
  8030.     tried.  For Unix the default is adjusted at compile time to where the
  8031.     help files are being installed.  See |option_backslash| about
  8032.     including spaces and backslashes.
  8033.  
  8034.                         *'helpheight'* *'hh'*
  8035. helpheight (hh)        number    (default 20)
  8036.             global
  8037.             {not in Vi}
  8038.     Minimal initial height of the help window when it is opened with the
  8039.     ":help" command.  The initial height of the help window is half of the
  8040.     current window, or (when the 'ea' option is on) the same as other
  8041.     windows.  When the height is less than 'helpheight', the height is
  8042.     set to 'helpheight'.  Set to zero to disable.
  8043.  
  8044.                      *'hidden'* *'hid'* *'nohidden'* *'nohid'*
  8045. hidden (hid)        toggle    (default off)
  8046.             global
  8047.             {not in Vi}
  8048.     When off the current buffer is unloaded when it is abandoned.  When
  8049.     on the current buffer becomes hidden when starting to edit another
  8050.     buffer.  If the current buffer is also displayed in another window it
  8051.     does not become hidden.  The commands that move through the buffer
  8052.     list make the current buffer hidden although the 'hidden' option is
  8053.     off.  See also |vim_win.txt|.
  8054.  
  8055.                         *'highlight'* *'hl'*
  8056. highlight (hl)        string    (default "8b,db,es,hs,mb,Mn,nu,rs,sr,tb,vr,ws")
  8057.             global
  8058.             {not in Vi}
  8059.     This option can be used to set highlighting mode for various
  8060.     occasions.  It is a comma separated list of character pairs.  The
  8061.     first character in a pair gives the occasion, the second the mode to
  8062.     use for that occasion.  The occasions are:
  8063.         8    Meta & special keys listed with ":map"
  8064.         d    directories in CTRL-D listing
  8065.         e    error messages
  8066.         h    help file headers
  8067.         m    "--More--" message
  8068.         M    Mode (e.g., "-- INSERT --")
  8069.         n    line number for ":number" and ":#" commands
  8070.         r    return to continue message and yes/no questions
  8071.         s    status lines
  8072.         t    Titles for output from ":set all", ":autocmd" etc.
  8073.         v    Visual mode
  8074.         w    warning messages
  8075.     The display modes are:
  8076.         r    reverse        (termcap entry "mr" and "me")
  8077.         i    italic        (termcap entry "ZH" and "ZR")
  8078.         b    bold        (termcap entry "md" and "me")
  8079.         s    standout    (termcap entry "so" and "se")
  8080.         u    underline    (termcap entry "us" and "ue")
  8081.         n    no highlighting
  8082.     The default is used for occasions that are not included.
  8083.  
  8084.                         *'history'* *'hi'*
  8085. history (hi)        number    (default 20)
  8086.             global
  8087.             {not in Vi}
  8088.     A history of ":" commands, and a history of previous search patterns
  8089.     are remembered.  This option decides how many entries may be stored in
  8090.     each of these histories (see |cmdline_editing|).
  8091.  
  8092.                      *'hkmap'* *'hk'* *'nohkmap'* *'nohk'*
  8093. hkmap (kh)        toggle  (default off)
  8094.             global
  8095.             {not in Vi}
  8096.             {Only available if Vim was compiled with RIGHTLEFT
  8097.             defined}
  8098.     When on, the keyboard is mapped for the Hebrew character set.
  8099.     Normally you would use CTRL-_ in insert mode to toggle this option.
  8100.     See |vim_rlh.txt|.
  8101.  
  8102.                         *'icon'* *'noicon'*
  8103. icon            toggle    (default off, on when title can be restored)
  8104.             global
  8105.             {not in Vi}
  8106.     When on the icon of the window will be set to the name of the file
  8107.     currently being edited.  Only the last part of the name is used.  Only
  8108.     works if the terminal supports setting window icons (currently only
  8109.     Unix xterm and iris-ansi).  When Vim was compiled with HAVE_X11
  8110.     defined, the original icon will be restored if possible |X11|.
  8111.  
  8112.                    *'ignorecase'* *'ic'* *'noignorecase'* *'noic'*
  8113. ignorecase (ic)        toggle    (default off)
  8114.             global
  8115.     Ignore case in search patterns.  Also used when searching in the tags
  8116.     file.
  8117.  
  8118.                         *'include'* *'inc'*
  8119. include (inc)        string    (default "^#[ \t]*include")
  8120.             global
  8121.             {not in Vi}
  8122.     Pattern to be used to find an include command.  It is a search
  8123.     pattern, just like for the "/" command (See 6.6, "Pattern
  8124.     searches" |search_pattern|).  The default value is for C programs.
  8125.     This option is used for the commands "[i", "]I", "[d", etc..  The
  8126.     'isfname' option is used to recognize the file name that comes after
  8127.     the matched pattern.  See |option_backslash| about including spaces
  8128.     and backslashes.
  8129.  
  8130.                  *'incsearch'* *'is'* *'noincsearch'* *'nois'*
  8131. incsearch (is)        toggle    (default off)
  8132.             global
  8133.             {not in Vi}
  8134.     While typing a search pattern, show immediately where the so far
  8135.     typed pattern matches.  The matched string is highlighted.  If the
  8136.     pattern is invalid or not found, nothing is shown.  The screen will
  8137.     be updated often, this is only useful on fast terminals.
  8138.  
  8139.                    *'infercase'* *'inf'* *'noinfercase'* *'noinf'*
  8140. infercase (inf)        toggle    (default off)
  8141.             local to buffer
  8142.             {not in Vi}
  8143.     When doing keyword completion in insert mode |ins_completion|, and
  8144.     'ignorecase' is also on, the case of the match is adjusted.  If the
  8145.     typed text contains a lowercase letter where the match has an upper
  8146.     case letter, the completed part is made lower case.  If the typed text
  8147.     has no lower case letters and the match has a lower case letter where
  8148.     the typed text has an upper case letter, and there is a letter before
  8149.     it, the completed part is made uppercase.
  8150.  
  8151.                    *'insertmode'* *'im'* *'noinsertmode'* *'noim'*
  8152. insertmode (im)        toggle    (default off)
  8153.             global
  8154.             {not in Vi}
  8155.     Start the edit of a file in Insert mode.  Useful if you want to use
  8156.     Vim like a modeless editor (use the cursor keys to move around, use
  8157.     CTRL-O for other commands |i_CTRL-O|).
  8158.  
  8159.                         *'isfname'* *'isf'*
  8160. isfname (isf)        string    (default for MS-DOS, Win32 and OS/2:
  8161.                         "@,48-57,/,.,-,_,+,,,$,:,\"
  8162.                  for AMIGA: "@,48-57,/,.,-,_,+,,,$,:"
  8163.                  otherwise: "@,48-57,/,.,-,_,+,,,$,:,~")
  8164.             global
  8165.             {not in Vi}
  8166.     The characters given by this option are included in file names and
  8167.     path names.  File names are used for commands like "gf", "[i" and in
  8168.     the tags file.  Besides the characters in this option characters that
  8169.     are defined by the C function isalpha() are also always included
  8170.     (this depends on the character set and "locale").
  8171.  
  8172.     The format of this option is a list of parts, separated with commas.
  8173.     Each part can be a single character number or a range.  A range is two
  8174.     character numbers with '-' in between.  A character number can be a
  8175.     decimal number between 0 and 255 or the ASCII character itself (does
  8176.     not work for digits).  Example:
  8177.         "_,-,128-140,#-43"    (include '_' and '-' and the range
  8178.                     128 to 140 and '#' to 43)
  8179.     If a part starts with '^', the following character number or range
  8180.     will be excluded from the option.  The option is interpreted from left
  8181.     to right.  Put the excluded character after the range where it is
  8182.     included.  To include '^' itself use it as the last character of the
  8183.     option or the end of a range.  Example:
  8184.         "^a-z,#,^"    (exclude 'a' to 'z', include '#' and '^')
  8185.     If the character is '@', all characters where isalpha() returns TRUE
  8186.     are included.  Normally these are the characters a to z and A to Z,
  8187.     plus accented characters.  To include '@' itself use "@-@".  Examples:
  8188.         "@,^a-z"    All alphabetic characters, excluding lower
  8189.                 case letters.
  8190.         "a-z,A-Z,@-@"    All letters plus the '@' character.
  8191.     A comma can be included by using it where a character number is
  8192.     expected.  Example:
  8193.         "48-57,,,_"    Digits, command and underscore.
  8194.     A comma can be excluded by prepending a '^'.  Example:
  8195.         " -~,^,,9"    All characters from space to '~', excluding
  8196.                 comma, plus <Tab>.
  8197.     See |option_backslash| about including spaces and backslashes.
  8198.  
  8199.                         *'isident'* *'isi'*
  8200. isident (isi)    string    (default for MS-DOS, Win32 and OS/2:
  8201.                        "@,48-57,_,128-167,224-235"
  8202.                 otherwise: "@,48-57,_,192-255")
  8203.             global
  8204.             {not in Vi}
  8205.     The characters given by this option are included in identifiers.
  8206.     Identifiers are used in recognizing environment variables and after
  8207.     a match of the 'define' option.  See 'isfname' for a description of
  8208.     the format of this option.
  8209.  
  8210.                         *'iskeyword'* *'isk'*
  8211. iskeyword (isk)         string (default for MS-DOS and Win32:
  8212.                         "@,48-57,_,128-167,224-235"
  8213.                 otherwise:  "@,48-57,_,192-255"
  8214.                 but when compiled with COMPATIBLE defined:
  8215.                         "@,48-57,_")
  8216.             local to buffer
  8217.             {not in Vi}
  8218.     Keywords are used in searching and recognizing with many commands:
  8219.     "*", "[i", etc.  See 'isfname' for a description of the format of this
  8220.     option.  For C programs you could use "a-z,A-Z,48-57,_,.,-,>".  For a
  8221.     help file it is set to all non-blank printable characters except '*',
  8222.     '"' and '|'.  When the 'lisp' option is on the '-' character is always
  8223.     included.
  8224.  
  8225.                         *'isprint'* *'isp'*
  8226. isprint (isp)    string    (default for MS-DOS and Win32: "@,~-255"
  8227.                   otherwise:           "@,161-255")
  8228.             global
  8229.             {not in Vi}
  8230.     The characters given by this option are displayed directly on the
  8231.     screen.  The characters from space (ascii 32) to '~' (ascii 126) are
  8232.     always displayed directly, even when they are not included in
  8233.     'isprint' or excluded.  See 'isfname' for a description of the format
  8234.     of this option.  Non-printable characters are displayed with two
  8235.     characters:
  8236.           0 -  31    "^@" - "^_"
  8237.          32 - 126    always single characters
  8238.            127        "^?"
  8239.         128 - 159    "~@" - "~_"
  8240.         160 - 254    "| " - "|~"
  8241.            255        "~?"
  8242.  
  8243.                    *'joinspaces'* *'js'* *'nojoinspaces'* *'nojs'*
  8244. joinspaces (js)        toggle    (default on)
  8245.             global
  8246.             {not in Vi}
  8247.     Insert two spaces after a period with a join command.
  8248.  
  8249.                     *'keywordprg'* *'kp'*
  8250. keywordprg (kp)        string    (default "man")
  8251.             global
  8252.             {not in Vi}
  8253.     Program to use for the "K" command.  Environment variables are
  8254.     expanded |:set_env|.  When empty ":help" is used.  See
  8255.     |option_backslash| about including spaces and backslashes.
  8256.  
  8257.                     *'langmap'* *'lmap'*
  8258. langmap (lmap)        string    (default "")
  8259.             global
  8260.             {not in Vi}
  8261.             {Only included when Vim was compiled with HAVE_LANGMAP
  8262.             defined (Check ":version" for "+langmap").
  8263.     This option allows support for keyboards that have a mode for a
  8264.     special language.  The idea is that when you are typing text in Insert
  8265.     mode your keyboard is switched in the special language mode, you get
  8266.     different key codes for the special characters.  When in command mode
  8267.     the 'langmap' option takes care of translating these special
  8268.     characters to the original meaning of the key.  This means you don't
  8269.     have to change the keyboard mode to be able to execute normal mode
  8270.     commands.
  8271.  
  8272.     Example (for greek):                    *greek*
  8273.         :set langmap=ÁA,ÂB,ØC,ÄD,ÅE,ÖF,ÃG,ÇH,ÉI,ÎJ,ÊK,ËL,ÌM,ÍN,ÏO,ÐP,QQ,ÑR,ÓS,ÔT,ÈU,ÙV,WW,×X,ÕY,ÆZ,áa,âb,øc,äd,åe,öf,ãg,çh,éi,îj,êk,ël,ìm,ín,ïo,ðp,qq,ñr,ós,ôt,èu,ùv,òw,÷x,õy,æz
  8274.     Example (exchanges meaning of z and y for commands):
  8275.         :set langmap=zy,yz,ZY,YZ
  8276.  
  8277.     The 'langmap' option is a list of parts, separated with commas.  Each
  8278.     part can be in one of two forms:
  8279.     1.  A list of pairs.  Each pair is a "from" character immediately
  8280.         followed by the "to" character.  Examples: "aA", "aAbBcC".
  8281.     2.  A list of "from" characters, a semi-colon and a list of "to"
  8282.         characters.  Example: "abc;ABC"
  8283.     Example: "aA,fgh;FGH,cCdDeE"
  8284.     Special characters need to be preceded with a backslash.  These are
  8285.     ";", ',' and backslash itself.
  8286.  
  8287.     This will allow you to activate vim actions without having to switch
  8288.     back and forth between the languages.  Your language characters will
  8289.     be understood as normal vim English characters (according to the
  8290.     langmap mappings) in the following cases:
  8291.      o Normal/Visual mode (commands, buffer/register names, user mappings)
  8292.      o Insert/Replace Mode: Register names after CTRL-R
  8293.      o Insert/Replace Mode: Mappings
  8294.     Characters entered in Command-line mode will NOT be affected by
  8295.     this option.   Note that this option can be changed at any time
  8296.     allowing to switch between mappings for different languages/encodings.
  8297.     Use a mapping to avoid having to type it each time!
  8298.  
  8299.                     *'laststatus'* *'ls'*
  8300. laststatus (ls)        number    (default 1)
  8301.             global
  8302.             {not in Vi}
  8303.     The value of this option influences when the last window will have a
  8304.     status line:
  8305.         0: never
  8306.         1: only if there are at least two windows
  8307.         2: always
  8308.     The screen looks nicer with a status line if you have several
  8309.     windows, but it takes another screen line.
  8310.  
  8311.                    *'linebreak'* *'lbr'* *'nolinebreak'* *'nolbr'*
  8312. linebreak (lbr)        toggle    (default off)
  8313.             local to window
  8314.             {not in Vi}
  8315.     If on Vim will wrap long lines at a character in 'breakat' rather
  8316.     than at the last character that fits on the screen.  Unlike
  8317.     'wrapmargin' and 'textwidth', this does not insert newline characters
  8318.     in the file, it only affects the way the file is displayed, not its
  8319.     contents.  The value of 'showbreak' is used to put in front of wrapped
  8320.     lines.  This option is not used when the 'wrap' option is off.  Note
  8321.     that <Tab> characters after a line break are mostly not displayed
  8322.     correctly.
  8323.  
  8324.                         *'lines'*
  8325. lines            number    (default 24 or terminal height)
  8326.             global
  8327.     Number of lines in the display.  Normally you don't need to set this.
  8328.     That is done automatically by the terminal initialization code.  When
  8329.     you do set this, and Vim is unable to change the physical number of
  8330.     lines on the display, redisplaying may be wrong.
  8331.  
  8332.                         *'lisp'* *'nolisp'*
  8333. lisp            toggle    (default off)
  8334.             local to buffer
  8335.             {Only included when compiled with LISPINDENT enabled,
  8336.             ":version" says "+lispindent" instead of
  8337.             "-lispindent"}
  8338.     Lisp mode: When a return is typed in insert mode set the indent for
  8339.     the next line to Lisp standards (well, sort of).  Also happens with
  8340.     "cc" or "S".  'autoindent' must also be on for this to work.  The '-'
  8341.     character is included in keyword characters.  Redefines the "="
  8342.     operator to use this same indentation algorithm rather than calling an
  8343.     external program if 'equalprg' is empty.  This option is reset when
  8344.     'paste' is set.  {Vi: Does it a little bit differently}
  8345.  
  8346.                         *'list'* *'nolist'*
  8347. list            toggle    (default off)
  8348.             local to window
  8349.     List mode: Show tabs as CTRL-I, show end of line with $.  Useful to
  8350.     see the difference between tabs and spaces and for trailing blanks.
  8351.     Note that this will also affect formatting (set with 'textwidth' or
  8352.     'wrapmargin').
  8353.  
  8354.                         *'magic'* *'nomagic'*
  8355. magic            toggle    (default on)
  8356.             global
  8357.     Changes the special characters that can be used in search patterns.
  8358.     See section "Pattern searches" |search_pattern|.
  8359.  
  8360.                         *'makeprg'* *'mp'*
  8361. makeprg (mp)        string    (default "make")
  8362.             global
  8363.             {not in Vi}
  8364.     Program to use for the ":make" command.  See |:make_makeprg|.  This
  8365.     option may contain '%' and '#' characters, which are expanded like
  8366.     when used in a command line.  Environment variables are expanded
  8367.     |:set_env|.  See |option_backslash| about including spaces and
  8368.     backslashes.
  8369.  
  8370.                         *'maxmapdepth'* *'mmd'*
  8371. maxmapdepth (mmd)    number    (default 1000)
  8372.             global
  8373.             {not in Vi}
  8374.     Maximum number of times a mapping is done without resulting in a
  8375.     character to be used.  This normally catches endless mappings, like
  8376.     ":map x y" with ":map y x".  It still does not catch ":map g wg",
  8377.     because the 'w' is used before the next mapping is done.  See also
  8378.     |key_mapping|.
  8379.  
  8380.                         *'maxmem'* *'mm'*
  8381. maxmem (mm)        number    (default 512)
  8382.             global
  8383.             {not in Vi}
  8384.     Maximum amount of memory (in Kbyte) to use for one buffer.  When this
  8385.     limit is reached allocating extra memory for a buffer will cause
  8386.     other memory to be freed.  See also 'maxmemtot'.
  8387.  
  8388.                         *'maxmemtot'* *'mmt'*
  8389. maxmemtot (mmt)        number    (default 2048, or half the amount of memory
  8390.                 available)
  8391.             global
  8392.             {not in Vi}
  8393.     Maximum amount of memory (in Kbyte) to use for all buffers together.
  8394.     See also 'maxmem'.
  8395.  
  8396.                    *'modeline'* *'ml'* *'nomodeline'* *'noml'*
  8397. modeline (ml)        toggle    (default on, off when compiled with COMPATIBLE
  8398.                 defined)
  8399.             local to buffer
  8400.                         *'modelines'* *'mls'*
  8401. modelines (mls)        number    (default 5)
  8402.             global
  8403.             {not in Vi}
  8404.     If 'modeline' is on 'modelines' gives the number of lines that is
  8405.     checked for set commands.  If 'modeline' is off or 'modelines' is zero
  8406.     no lines are checked.  See 19.1 |modeline|.  'modeline' is reset when
  8407.     'compatible' is set.
  8408.  
  8409.                  *'modified'* *'mod'* *'nomodified'* *'nomod'*
  8410. modified (mod)        toggle    (default off)
  8411.             local to buffer
  8412.             {not in Vi}
  8413.     When on the buffer is considered to be modified.  This option is set
  8414.     by every command that makes a change to the buffer.  Only the undo
  8415.     command may reset it, when all changes have been undone.
  8416.  
  8417.                         *'more'* *'nomore'*
  8418. more            toggle    (default on, off when compiled with COMPATIBLE
  8419.                 defined)
  8420.             global
  8421.             {not in Vi}
  8422.     Listings pause when the whole screen is filled.  Type:
  8423.          <CR> or <NL>   for one more line.
  8424.          <Space>        for the next page.
  8425.          'd'            for down half a page.
  8426.          'q' or CTRL-C  to stop the listing.
  8427.          ':'            to stop the listing and enter a command line.
  8428.     Any other key causes the meaning of the keys to be displayed.
  8429.     When this option is off there are no pauses, the listing continues
  8430.     until finished.  When 'compatible' is set this option is reset.
  8431.     Note: The key typed at the "more" prompt is directly obtained from the
  8432.     terminal, it is not mapped and typeahead is ignored.
  8433.  
  8434.                         *'mouse'*
  8435. mouse            string    (default "", "a" for MS-DOS and Win32)
  8436.             global
  8437.             {not in Vi}
  8438.     Enable the use of the mouse.  Only works for certain terminals
  8439.     (MS-DOS, Win32 and xterm).  The mouse can be enabled for different
  8440.     modes:
  8441.         n    Normal mode
  8442.         v    Visual mode
  8443.         i    Insert mode
  8444.         c    Command-line mode
  8445.         h    all previous modes when editing a help file
  8446.         a    all previous modes
  8447.         r    for "Hit return ..." question
  8448.     Normally you would enable the mouse in all four modes with:
  8449.         :set mouse=a
  8450.     Note: Normal copy/paste in an xterm can still be used by pressing the
  8451.     shift key when the mouse is being used by Vim.  See |mouse_using|.
  8452.  
  8453.                         *'mousetime'* *'mouset'*
  8454. mousetime (mouset)    number    (default 500)
  8455.             global
  8456.             {not in Vi}
  8457.     Only for GUI, MS-DOS, Win32 and Unix with xterm.  Defines the maximum
  8458.     time in msec between two mouse clicks for the second click to be
  8459.     recognized as a multi click.
  8460.  
  8461.                        *'number'* *'nu'* *'nonumber'* *'nonu'*
  8462. number (nu)        toggle    (default off)
  8463.             local to window
  8464.     Print the line number in front of each line.  Tip: If you don't like
  8465.     wrapping lines to mix with the line numbers, set the 'showbreak'
  8466.     option to eight spaces:
  8467.         :set showbreak=\ \ \ \ \ \ \ \ 
  8468.  
  8469.             *'paragraphs'* *'para'*
  8470. paragraphs (para)    string    (default "IPLPPPQPP LIpplpipbp")
  8471.             global
  8472.     Specifies the nroff macros that separate paragraphs.  These are pairs
  8473.     of two letters (see section 6.4 |object_motions|).
  8474.  
  8475.                         *'paste'* *'nopaste'*
  8476. paste            toggle    (default off)
  8477.             global
  8478.             {not in Vi}
  8479.     Put Vim in Paste mode.  This is useful if you want to cut or copy
  8480.     some text from one window and paste it in Vim.  This will avoid
  8481.     unexpected effects.  When the 'paste' option is switched on (also when
  8482.     it was already on):
  8483.         - mapping in Insert mode is disabled
  8484.         - abbreviations are disabled
  8485.         - 'textwidth' is set to 0
  8486.         - 'autoindent' is reset
  8487.         - 'smartindent' is reset
  8488.         - 'cindent' is reset
  8489.         - 'lisp' is reset
  8490.         - 'revins' is reset
  8491.         - 'ruler' is reset
  8492.         - 'showmatch' is reset
  8493.         - 'formatoptions' is used like it is empty
  8494.     NOTE: When you start editing another file while the 'paste' option is
  8495.     on, settings from the modelines or autocommands may change the
  8496.     settings again, causing trouble when pasting text.  You might want to
  8497.     set the 'paste' option again.
  8498.     When the 'paste' option is reset the mentioned options are restored to
  8499.     the value before the moment 'paste' was switched from off to on.
  8500.     Resetting 'paste' before ever setting it does not have any effect.  If
  8501.     you use this often, you could map a function key to the command ":set
  8502.     invpaste^V^M".
  8503.  
  8504.                         *'patchmode'* *'pm'*
  8505. patchmode (pm)        string    (default "")
  8506.             global
  8507.             {not in Vi}
  8508.     When non-empty the oldest version of a file is kept.  This can be used
  8509.     to keep the original version of a file if you are changing files in a
  8510.     source distribution.  Only the first time that a file is edited a copy
  8511.     of the original file will be kept.  The name of the copy is the name
  8512.     of the original file with the string in the 'patchmode' option
  8513.     appended.  This option should start with a dot.  Use a string like
  8514.     ".org".  'backupdir' must not be empty for this to work (Detail: The
  8515.     backup file is renamed to the patchmode file after the new file has
  8516.     been succesfully written, that's why it must be possible to write a
  8517.     backup file).  If there was no file to be backed up, an empty file is
  8518.     created.
  8519.  
  8520.                         *'path'* *'pa'*
  8521. path (pa)        string    (default on Unix: ".,/usr/include,,"
  8522.                    on OS/2:       ".,/emx/include,,"
  8523.                    other systems: ".,,")
  8524.             global
  8525.             {not in Vi}
  8526.     This is a list of directories which will be searched when using the
  8527.     gf, [f, ]f, ^Wf and other commands, provided that the file being
  8528.     searched for has a relative path (not starting with '/').  The
  8529.     directories in the 'path' option may be relative or absolute.
  8530.     - Use commas to separate directory names:
  8531.         :set path=.,/usr/local/include,/usr/include
  8532.     - Spaces can also be used to separate directory names (for backwards
  8533.       compatibility with version 3.0).  To have a space in a directory
  8534.       name, precede it with an extra backslash:
  8535.           :set path=.,/dir/with\\ space
  8536.     - To include a comma in a directory name precede it with an extra
  8537.       backslash:
  8538.           :set path=.,/dir/with\\,comma
  8539.     - To search relative to the directory where the current file is use
  8540.           :set path=.
  8541.     - To search in the current directory use an empty string between two
  8542.       commas:
  8543.         :set path=,,
  8544.     - A directory name may end in a ':' or '/'.
  8545.     - Environment variables are expanded |:set_env|.
  8546.     - Careful with '\' characters, type two to get one in the option:
  8547.         :set path=.,c:\\include
  8548.       Or just use '/' instead:
  8549.         :set path=.,c:/include
  8550.     Don't forget "." or files won't even be found in the same directory as
  8551.     the file!
  8552.  
  8553.                    *'readonly'* *'ro'* *'noreadonly'* *'noro'*
  8554. readonly (ro)        toggle    (default off)
  8555.             local to buffer
  8556.             {not in Vi}
  8557.     If on, writes fail unless you use a '!'.  Protects you from
  8558.     accidentally overwriting a file.  Default on when Vim is started
  8559.     in view mode ("vim -v") or when the executable is called "view".
  8560.     {not in Vi:}  When using the ":view" command the 'readonly' option is
  8561.     set for the newly edited buffer.  When using ":w!" the 'readonly'
  8562.     option is reset for the current buffer.
  8563.  
  8564.                         *'remap'* *'noremap'*
  8565. remap            toggle    (default on)
  8566.             global
  8567.     Allows for mappings to work recursively.  If you do not want this for
  8568.     a single entry, use the :noremap[!] command.
  8569.  
  8570.                         *'report'*
  8571. report            number    (default 2)
  8572.             global
  8573.     Threshold for reporting number of lines changed.  When the number of
  8574.     changed lines is more than 'report' a message will be given for most
  8575.     ":" commands.  For the ":substitute" command the number of
  8576.     substitutions is used instead of the number of lines.
  8577.  
  8578.              *'restorescreen'* *'rs'* *'norestorescreen'* *'nors'*
  8579. restorescreen (rs)    toggle    (default on)
  8580.             global
  8581.             {not in Vi}  {Windows 95/NT version only}
  8582.     When set, the screen contents is restored when exiting Vim.  This also
  8583.     happens when executing external commands.
  8584.  
  8585.                        *'revins'* *'ri'* *'norevins'* *'nori'*
  8586. revins (ri)        toggle    (default off)
  8587.             global
  8588.             {not in Vi}
  8589.             {only when compiled with RIGHTLEFT defined}
  8590.     Inserting characters in Insert mode will work backwards.  See "typing
  8591.     backwards" |ins_reverse|.  This option can be toggled with the CTRL-B
  8592.     command in Insert mode.  This option is reset when 'compatible' or
  8593.     'paste' is set.
  8594.  
  8595.                  *'rightleft'* *'rl'* *'norightleft'* *'norl'*
  8596. rightleft (rl)        toggle    (default off)
  8597.             local to window
  8598.             {not in Vi}
  8599.             {only when compiled with RIGHTLEFT defined}
  8600.     When on, display orientation becomes right-to-left, i.e., character
  8601.     that are stored in the file apear from the right to the left.  Using
  8602.     this option, it is possible to edit files for languages that are
  8603.     written from the right to the left such as Hebrew and Arabic.  This
  8604.     option is per window, so it is possible to edit mixed files
  8605.     simultaneously, or to view the same file in both ways (this is
  8606.     sometimes usefull when editing Hebrew TeX--XeT files).  See
  8607.     |vim_rlh.txt|.
  8608.  
  8609.                      *'ruler'* *'ru'* *'noruler'* *'noru'*
  8610. ruler (ru)        toggle    (default off)
  8611.             global
  8612.             {not in Vi}
  8613.     Show the line and column number of the cursor position in the status
  8614.     line, separated by a comma.  If there are characters in the line that
  8615.     take two positions on the screen, both the "real" column and the
  8616.     screen column are shown, separated with a dash.  For an empty line
  8617.     "0-1" is shown.  For an empty buffer the line number will also be
  8618.     zero: "0,0-1".  This option is reset when the 'paste' option is set.
  8619.     If you don't want to see the ruler all the time but want to know where
  8620.     you are, use "g CTRL-G" |g_CTRL-G|.
  8621.  
  8622.                         *'scroll'* *'scr'*
  8623. scroll (scr)        number    (default 'lines' / 2)
  8624.             local to window
  8625.     Number of lines to scroll with CTRL-U and CTRL-D commands.  Will be
  8626.     set to half the number of lines in the window when the window size
  8627.     changes.  If you give a count to the CTRL-U or CTRL-D command it will
  8628.     be used as the new value for 'scroll'.  Reset to 'lines' / 2 with
  8629.     ":set scroll=0".   {difference from vi: 'scroll' gives the number of
  8630.     screen lines instead of file lines, makes a difference when lines
  8631.     wrap}
  8632.  
  8633.                         *'scrolljump'* *'sj'*
  8634. scrolljump (sj)        number    (default 1)
  8635.             global
  8636.             {not in Vi}
  8637.     Minimal number of lines to scroll when the cursor gets off the
  8638.     screen (e.g., with "j").  Not used for scroll commands (e.g., CTRL-E,
  8639.     CTRL-D).  Useful if your terminal scrolls very slowly.
  8640.  
  8641.                         *'scrolloff'* *'so'*
  8642. scrolloff (so)        number    (default 0)
  8643.             global
  8644.             {not in Vi}
  8645.     Minimal number of screen lines to keep above and below the cursor.
  8646.     This will make some context visible around where you are working.  If
  8647.     you set it to a very large value (999) the cursor line will always be
  8648.     in the middle of the window (except at the start or end of the file or
  8649.     when long lines wrap).
  8650.  
  8651.                         *'sections'* *'sect'*
  8652. sections (sect)        string    (default "SHNHH HUnhsh")
  8653.             global
  8654.     Specifies the nroff macros that separate sections.  These are pairs of
  8655.     two letters (See section 6.4 |object_motions|).
  8656.  
  8657.                         *'secure'* *'nosecure'*
  8658. secure            toggle    (default off)
  8659.             global
  8660.             {not in Vi}
  8661.     When on, ":autocmd", shell and write commands are not allowed in
  8662.     ".vimrc" and ".exrc" in the current directory and map commands are
  8663.     displayed.  Switch it off only if you know that you will not run into
  8664.     problems, or when the 'exrc' option is off.  On Unix this option is
  8665.     only used if the ".vimrc" or ".exrc" is not owned by you.  This can be
  8666.     dangerous if the systems allows users to do a "chown".  You better set
  8667.     'secure' at the end of your ~/.vimrc then.
  8668.  
  8669.                         *'shell'* *'sh'*
  8670. shell (sh)        string    (default $SHELL or "sh",
  8671.                     MS-DOS and Win32: "command",
  8672.                     OS/2: "cmd")
  8673.             global
  8674.     Name of the shell to use for ! and :! commands.  When changing the
  8675.     value also check the 'shelltype', 'shellpipe' and 'shellredir'
  8676.     options.  It is allowed to give an argument to the command, e.g.
  8677.     "csh -f".  See |option_backslash| about including spaces and
  8678.     backslashes.  Environment variables are expanded |:set_env|.
  8679.  
  8680.                         *'shellpipe'* *'sp'*
  8681. shellpipe (sp)        string    (default ">", "| tee", "|& tee" or "2>&1| tee")
  8682.             global
  8683.             {not in Vi}
  8684.     String to be used to put the output of the ":make" command in the
  8685.     error file.  See also |:make_makeprg|.  See |option_backslash| about
  8686.     including spaces and backslashes.
  8687.     For the Amiga and MS-DOS the default is ">".  The output is directly
  8688.     saved in a file and not echoed to the screen.
  8689.     For Unix the default it "| tee".  The stdout of the compiler is saved
  8690.     in a file and echoed to the screen.  If the 'shell' option is "csh" or
  8691.     "tcsh" after initializations, the default becomes "|& tee".  If the
  8692.     'shell' option is "sh", "ksh", "zsh" or "bash" the default becomes
  8693.     "2>&1| tee".  This means that stderr is also included.
  8694.     The initialization of this option is done after reading the ".vimrc"
  8695.     and the other initializations, so that when the 'shell' option is set
  8696.     there, the 'shellpipe' option changes automatically, unless it was
  8697.     explicitly set before.
  8698.     In the future pipes may be used for filtering and this option will
  8699.     become obsolete (at least for Unix).
  8700.  
  8701.                         *'shellredir'* *'srr'*
  8702. shellredir (srr)    string    (default ">", ">&" or ">%s 2>&1")
  8703.             global
  8704.             {not in Vi}
  8705.     String to be used to put the output of a filter in a temporary file.
  8706.     See also |:!|.  See |option_backslash| about including spaces and
  8707.     backslashes.
  8708.     The name of the temporary file can be represented by "%s" if necessary
  8709.     (the file name is appended automatically if no %s appears in the value
  8710.     of this option).
  8711.     The default is ">".  For Unix, if the 'shell' option is "csh", "tcsh"
  8712.     or "zsh" during initializations, the default becomes ">&".  If the
  8713.     'shell' option is "sh", "ksh" or "bash" the default becomes
  8714.     ">%s 2>&1".  This means that stderr is also included.
  8715.     The initialization of this option is done after reading the ".vimrc"
  8716.     and the other initializations, so that when the 'shell' option is set
  8717.     there, the 'shellredir' option changes automatically unless it was
  8718.     explicitly set before.
  8719.     In the future pipes may be used for filtering and this option will
  8720.     become obsolete (at least for Unix).
  8721.  
  8722.                         *'shelltype'* *'st'*
  8723. shelltype (st)        number    (default 0)
  8724.             global
  8725.             {not in Vi}
  8726.     On the Amiga this option influences the way how the commands work
  8727.     which use a shell.
  8728.     0 and 1: always use the shell
  8729.     2 and 3: use the shell only to filter lines
  8730.     4 and 5: use shell only for ':sh' command
  8731.     When not using the shell, the command is executed directly.
  8732.  
  8733.     0 and 2: use 'shell -c cmd' to start external commands
  8734.     1 and 3: use 'shell cmd' to start external commands
  8735.  
  8736.                    *'shiftround'* *'sr'* *'noshiftround'* *'nosr'*
  8737. shiftround (sr)        toggle    (default off)
  8738.             global
  8739.             {not in Vi}
  8740.     Round indent to multiple of 'shiftwidth'.  Applies to > and <
  8741.     commands.  CTRL-T and CTRL-D in Insert mode always round the indent to
  8742.     a multiple of 'shiftwidth' (this is vi compatible).
  8743.  
  8744.                         *'shiftwidth'* *'sw'*
  8745. shiftwidth (sw)        number    (default 8)
  8746.             local to buffer
  8747.     Number of spaces to use for each step of (auto)indent.
  8748.  
  8749.                         *'shortmess'* *'shm'*
  8750. shortmess (shm)        string    (default "")
  8751.             global
  8752.             {not in Vi}
  8753.     This option helps to avoid all the "Hit return" messages caused by
  8754.     file messages, for example  with CTRL-G, and to avoid some other
  8755.     messages.  It is a list of flags:
  8756.      flag    meaning when present
  8757.       l    use "999L, 888C" instead of "999 lines, 888 characters"
  8758.       m    use "[+]" instead of "[Modified]"
  8759.       r    use "[RO]" instead of "[readonly]"
  8760.       x    use "[tx]" instead of "[textmode]" and "[notx]" instead of
  8761.         "[notextmode]"
  8762.       f    use "(3 of 5)" instead of "(file 3 of 5)"
  8763.       i    use "[noeol]" instead of "[Incomplete last line]"
  8764.       n    use "[New]" instead of "[New File]"
  8765.       w    use "[w]" instead of "written" for file write message.
  8766.       a    all of the above abbreviations
  8767.  
  8768.       o    overwrite message for writing a file with subsequent message
  8769.         for reading a file (useful for ":wn" or when 'autowrite' on)
  8770.       W    don't give "written" or "[w]" when writing a file
  8771.       s    don't give "search hit BOTTOM, continuing at TOP" or "search
  8772.         hit TOP, continuing at BOTTOM" messages
  8773.       t    trunctate file message at the start if it is too long to fit
  8774.         on the command line, "<" will appear in the left most column.
  8775.     This gives you the opportunity to avoid that a change between buffers
  8776.     requires you to hit return, but still gives as useful a message as
  8777.     possible for the space available.  To get the whole message that you
  8778.     would have got with 'shm' empty, use ":file!"
  8779.     Useful values:
  8780.         shm=    -- No abbreviation of message.
  8781.         shm=a    -- Abbreviation, but no loss of information.
  8782.         shm=at    -- Abbreviation, and truncate message when necessary.
  8783.  
  8784.                  *'shortname'* *'sn'* *'noshortname'* *'nosn'*
  8785. shortname (sn)        toggle    (default off)
  8786.             local to buffer
  8787.             {not in Vi}
  8788.     Filenames can be 8 characters plus one extension of 3 characters.
  8789.     Multiple dots in file names are not allowed.  When this option is on,
  8790.     dots in filenames are replaced with underscores when adding an
  8791.     extension (".~" or ".swp").  This option is not available for
  8792.     MS-DOS and Win32, because then it would always be on.  This option is
  8793.     useful when editing files on an MS-DOS compatible filesystem, e.g.,
  8794.     messydos or crossdos.
  8795.  
  8796.                         *'showbreak'* *'sbr'*
  8797. showbreak (sbr)        string    (default "")
  8798.             global
  8799.             {not in Vi}
  8800.     String to put at the start of lines that have been wrapped.  Useful
  8801.     values are "> " or "+++ ".  Only printable characters are allowed,
  8802.     excluding <Tab> and comma (in a future version the comma might be used
  8803.     to separate the part that is shown at the end and at the start of a
  8804.     line).
  8805.  
  8806.                      *'showcmd'* *'sc'* *'noshowcmd'* *'nosc'*
  8807. showcmd (sc)        toggle    (default on, off for Unix)
  8808.             global
  8809.             {not in Vi}
  8810.     Show (partial) command in status line.  Set this option off if your
  8811.     terminal is slow.
  8812.  
  8813.                  *'showmatch'* *'sm'* *'noshowmatch'* *'nosm'*
  8814. showmatch (sm)        toggle    (default off)
  8815.             global
  8816.     When a bracket is inserted, briefly jump to the matching one.  The
  8817.     jump is only done if the match can be seen on the screen.
  8818.     A Beep is given if there is no match (no matter if the match can be
  8819.     seen or not).  This option is reset when the 'paste' option is set.
  8820.     When the 'm' flag is not included in 'cpoptions', typing a character
  8821.     will immediately move the cursor back to where it belongs.
  8822.  
  8823.                  *'showmode'* *'smd'* *'noshowmode'* *'nosmd'*
  8824. showmode (smd)        toggle    (default on, off when compiled with COMPATIBLE
  8825.                 defined)
  8826.             global
  8827.     If in Insert, Replace or Visual mode put a message on the last line.
  8828.     Use the 'M' flag in 'highlight' to set the type of highlighting for
  8829.     this message.
  8830.  
  8831.                         *'sidescroll'* *'ss'*
  8832. sidescroll (ss)        number    (default 0)
  8833.             global
  8834.             {not in Vi}
  8835.     The minimal number of columns to scroll horizontally.  Used only when
  8836.     the 'wrap' option is off and the cursor is moved off of the screen.
  8837.     When it is zero the cursor will be put in the middle of the screen.
  8838.     When using a slow terminal set it to a large number or 0.  When using
  8839.     a fast terminal use a small number or 1.  Not used for "zh" and "zl"
  8840.     commands.
  8841.  
  8842.                    *'smartcase'* *'scs'* *'nosmartcase'* *'noscs'*
  8843. smartcase (scs)        toggle    (default off)
  8844.             global
  8845.             {not in Vi}
  8846.     Override the 'ignorecase' option if the search pattern contains upper
  8847.     case characters.  Only used when the search pattern is typed and
  8848.     'ignorecase' option is on.  Used for the commands "/", "?", "n", "N",
  8849.     ":g" and ":s".  Not used for "*", "#", "gd", tag search, etc..
  8850.  
  8851.                  *'smartindent'* *'si'* *'nosmartindent'* *'nosi'*
  8852. smartindent (si)    toggle    (default off)
  8853.             local to buffer
  8854.             {not in Vi}
  8855.             {Only included when compiled with SMARTINDENT defined,
  8856.             check with ":version"}
  8857.     Do smart autoindenting when starting a new line.  Works best for C
  8858.     programs, but can also be used for other languages.  'cindent' does
  8859.     something like this, works better in most cases, but is more strict,
  8860.     see |C_indenting|.  When 'cindent' is on setting 'si' has no effect.
  8861.     Normally 'autoindent' should also be on when using 'smartindent'.
  8862.     An indent is automatically inserted:
  8863.     - After a line ending in '{'.
  8864.     - After a line starting with a keyword from 'cinwords'.
  8865.     - Before a line starting with '}' (only with the "O" command).
  8866.     When typing '}' as the first character in a new line, that line is
  8867.     given the same indent as the matching '{'.
  8868.     When typing '#' as the first character in a new line, the indent for
  8869.     that line is removed, the '#' is put in the first column.  The indent
  8870.     is restored for the next line.  If you don't want this, use this
  8871.     mapping: ":inoremap # X^H#", where ^H is entered with CTRL-V CTRL-H.
  8872.     When using the ">>" command, lines starting with '#' are not shifted
  8873.     right.
  8874.     'smartindent' is reset when the 'paste' option is set.
  8875.  
  8876.                  *'smarttab'* *'sta'* *'nosmarttab'* *'nosta'*
  8877. smarttab (sta)        toggle    (default off)
  8878.             global
  8879.             {not in Vi}
  8880.     When on, a <Tab> in front of a line inserts 'shiftwidth' positions,
  8881.     'tabstop' in other places.  When off a <Tab> always inserts 'tabstop'
  8882.     positions, 'shiftwidth' is only used for ">>" and the like.  See also
  8883.     section 4.3.4 |ins_expandtab|.
  8884.  
  8885.                    *'splitbelow'* *'sb'* *'nosplitbelow'* *'nosb'*
  8886. splitbelow (sb)        toggle    (default off)
  8887.             global
  8888.             {not in Vi}
  8889.     When on, spliting a window will put the new window below the current
  8890.     one.
  8891.  
  8892.                *'startofline'* *'sol'* *'nostartofline'* *'nosol'*
  8893. startofline (sol)    toggle    (default on)
  8894.             global
  8895.             {not in Vi}
  8896.     When on the commands listed below move the cursor to the first
  8897.     blank of the line.  When off the cursor is kept in the same column
  8898.     (if possible).  This applies to the commands: CTRL-D, CTRL-U, CTRL-B,
  8899.     CTRL-F, "G", "H", "M", "L", , and to the commands "d", "<<" and ">>"
  8900.     with a linewise operator and with "%" with a count.  This option is
  8901.     set when the 'compatible' option is set.
  8902.  
  8903.                         *'suffixes'* *'su'*
  8904. suffixes (su)        string    (default ".bak,~,.o,.h,.info,.swp")
  8905.             global
  8906.             {not in Vi}
  8907.     Files with these suffixes are ignored when multiple files match a
  8908.     wildcard.  See |suffixes|.  Commas can be used to separate the
  8909.     suffixes.  Spaces after the comma are ignored.  A dot is also seen as
  8910.     the start of a suffix.  To include a dot or comma in a suffix, precede
  8911.     it with a backslash (see |option_backslash| about including spaces and
  8912.     backslashes).
  8913.  
  8914.                         *'swapsync'* *'sws'*
  8915. swapsync (sws)        string    (default "fsync")
  8916.             global
  8917.             {not in Vi}
  8918.     When this option is not empty a swap file is synced to disk after
  8919.     writing to it.  This takes some time, especially on busy unix systems.
  8920.     When this option is empty parts of the swap file may be in memory and
  8921.     not written to disk.  When the system crashes you may lose more work.
  8922.     On Unix the system does a sync now and then without Vim asking for it,
  8923.     so the disadvantage of setting this option off is small.  On some
  8924.     systems the swap file will not be written at all.  For a unix system
  8925.     setting it to "sync" will use the sync() call instead of the default
  8926.     fsync(), which may work better on some systems.
  8927.  
  8928.                     *'tabstop'* *'ts'*
  8929. tabstop (ts)        number    (default 8)
  8930.             local to buffer
  8931.     Number of spaces that a <Tab> in the file counts for.  (See also
  8932.     ":retab" command in 11.3 |:retab|).
  8933.  
  8934.                         *'taglength'* *'tl'*
  8935. taglength (tl)        number    (default 0)
  8936.             global
  8937.     If non-zero, tags are significant up to this number of characters.
  8938.  
  8939.                  *'tagrelative'* *'tr'* *'notagrelative'* *'notr'*
  8940. tagrelative (tr)    toggle    (default on, off when compiled with COMPATIBLE
  8941.                 defined)
  8942.             global
  8943.             {not in Vi}
  8944.     If on and using a tag file in another directory, file names in that
  8945.     tag file are relative to the directory where the tag file is.  When
  8946.     the 'compatible' option is set, this option is reset.
  8947.  
  8948.                         *'tags'* *'tag'*
  8949. tags (tag)        string    (default "./tags,tags", when compiled with
  8950.                 Emacs tags enabled: "./tags,./TAGS,tags,TAGS")
  8951.             global
  8952.     Filenames for the tag command, separated by spaces or commas.  To
  8953.     include a space or comma in a filename, precede it with a backslash
  8954.     (see |option_backslash| about including spaces and backslashes).
  8955.     When a file name starts with "./", the '.' is replaced with the path
  8956.     of the current file.  Environment variables are expanded |:set_env|.
  8957.     Also see |tags_option|.
  8958.     When Vim was compiled with EMACS_TAGS defined Emacs-style tag files
  8959.     are also supported.  They are automatically recognized.  The default
  8960.     value becomes "./tags,./TAGS,tags,TAGS".  If ":version" shows
  8961.     "+emacs_tags" then the Emacs tags support is included.  {Vi: default
  8962.     is "tags /usr/lib/tags"}
  8963.  
  8964.                         *'term'*
  8965. term            string    (default is $TERM, if that fails:
  8966.                      on Unix: "ansi"
  8967.                         on Amiga: "amiga"
  8968.                        on MS-DOS: "pcterm"
  8969.                          on OS/2: "os2ansi"
  8970.                        on Win 32: "win32")
  8971.             global
  8972.     Name of the terminal.  Used for choosing the terminal control
  8973.     characters.  Environment variables are expanded |:set_env|.
  8974.     For example:
  8975.         :set term=$TERM
  8976.     See |termcap|.
  8977.  
  8978.                         *'terse'* *'noterse'*
  8979. terse            toggle    (default off)
  8980.             global
  8981.             {not in Vi}
  8982.     When set: Add 's' flag to 'shortmess' option (this makes the message
  8983.     for a search that hits the start or end of the file not being
  8984.     displayed).  When reset: Remove 's' flag from 'shortmess' option.  {Vi
  8985.     shortens a lot of messages}
  8986.  
  8987.                    *'textauto'* *'ta'* *'notextauto'* *'nota'*
  8988. textauto (ta)        toggle    (default on, off when compiled with COMPATIBLE
  8989.                 defined)
  8990.             global
  8991.             {not in Vi}
  8992.     When starting to edit a file a check is done for the line separator.
  8993.     If all lines end in <CR><NL> 'textmode' is set, otherwise 'textmode'
  8994.     is reset.  When reading a file, the same is done, but this happens
  8995.     like 'textmode' has been set appropriately for that file only, the
  8996.     option is not changed.  See |textmode_io|.
  8997.  
  8998.                    *'textmode'* *'tx'* *'notextmode'* *'notx'*
  8999. textmode (tx)        toggle    (MS-DOS, Win32 and OS/2: default on, others:
  9000.                 default off)
  9001.             local to buffer
  9002.             {not in Vi}
  9003.     When off, <NL> separates lines.  When on, <CR><NL> separates lines
  9004.     and CTRL-Z at end of file is ignored.  Only used when reading and
  9005.     writing files.  Set automatically when starting to edit a file and
  9006.     'textauto' is on.  See |textmode_io|.
  9007.  
  9008.                         *'textwidth'* *'tw'*
  9009. textwidth (tw)        number    (default 0)
  9010.             local to buffer
  9011.             {not in Vi}
  9012.     Maximum width of text that is being inserted.  A longer line will be
  9013.     broken after white space to get this width.  A zero value disables
  9014.     this.  'textwidth' is set to 0 when the 'paste' option is set.  When
  9015.     'textwidth' is zero, 'wrapmargin' may be used.  See also
  9016.     'formatoptions' and |ins_textwidth|.
  9017.  
  9018.                  *'tildeop'* *'top'* *'notildeop'* *'notop'*
  9019. tildeop (top)        toggle    (default off)
  9020.             global
  9021.             {not in Vi}
  9022.     When on: The tilde command "~" behaves like an operator.
  9023.  
  9024.                 *'timeout'* *'to'* *'notimeout'* *'noto'*
  9025. timeout    (to)        toggle (default on)
  9026.             global
  9027.                         *'ttimeout'* *'nottimeout'*
  9028. ttimeout        toggle (default off)
  9029.             global
  9030.             {not in Vi}
  9031.     These two options together determine the behaviour when part of a
  9032.     mapped key sequence or keyboard code has been received:
  9033.  
  9034.     timeout        ttimeout    action
  9035.     off        off        no time out
  9036.     on        on or off    time out on :mappings and key codes
  9037.     off        on        time out on key codes
  9038.  
  9039.     If there is no time out, Vim will wait until either the complete
  9040.     mapping or key sequence has been received, or it is clear that there
  9041.     is no mapping or key sequence for the received characters.  For
  9042.     example: if you have mapped "vl" and Vim has received 'v', the next
  9043.     character is needed to see if the 'v' is followed by an 'l'.  With a
  9044.     time out Vim will wait for about 1 second for the next character to
  9045.     arrive.  After that the already received characters are interpreted
  9046.     as single characters.  The waiting time can be changed with the
  9047.     'timeoutlen' option.
  9048.     On slow terminals or very busy systems time out may cause
  9049.     malfunctioning cursor keys.  If both options are off, Vim waits
  9050.     forever after an entered <Esc> if there are key codes that start
  9051.     with <Esc>.  You will have to type <Esc> twice.  If you do not have
  9052.     problems with key codes, but would like to have :mapped key
  9053.     sequences not time out in 1 second, set the ttimeout option and
  9054.     reset the timeout option.
  9055.  
  9056.                         *'timeoutlen'* *'tm'*
  9057. timeoutlen (tm)        number    (default 1000)
  9058.             global
  9059.             {not in all versions of Vi}
  9060.                         *'ttimeoutlen'* *'ttm'*
  9061. ttimeoutlen (ttm)    number    (default -1)
  9062.             global
  9063.             {not in Vi}
  9064.     The time in milliseconds that is waited for a key code or mapped key
  9065.     sequence to complete.  Normally only 'timeoutlen' is used and
  9066.     'ttimeoutline' is -1.  When a different timeout value for key codes is
  9067.     desired set 'ttimeoutlen' to a non-negative number.
  9068.  
  9069.         ttimeoutlen    mapping delay       key code delay
  9070.                < 0          'timeoutlen'       'timeoutlen'
  9071.               >= 0          'timeoutlen'       'ttimeoutlen'
  9072.  
  9073.     The timeout only happens when the 'timeout' and 'ttimeout' options
  9074.     tell so.  A useful setting would be
  9075.         :set timeout timeoutlen=3000 ttimeloutlen=100
  9076.     (time out on mapping after three seconds, time out on key codes after
  9077.     a tenth of a second).
  9078.  
  9079.                         *'title'* *'notitle'*
  9080. title            toggle    (default off, on when title can be restored)
  9081.             global
  9082.             {not in Vi}
  9083.     When on the title of the window will be set to "VIM - filename",
  9084.     where filename is the name of the file currently being edited.  Only
  9085.     works if the terminal supports setting window titles (currently Amiga
  9086.     console, Unix xterm and iris-ansi).
  9087.                                 *X11*
  9088.     When Vim was compiled with HAVE_X11 defined, the original title will
  9089.     be restored if possible.  The output of ":version" will include "+X11"
  9090.     when HAVE_X11 was defined, otherwise it will be "-X11".  This also
  9091.     works for the icon name |'icon'|.
  9092.     If the title cannot be restored, it is set to "Thanks for flying Vim".
  9093.     You will have to restore the title outside of Vim then.  When using an
  9094.     xterm from a remote machine you can use this command:
  9095.         rsh machine_name xterm -display $DISPLAY &
  9096.     then the WINDOWID environment variable should be inherited and the
  9097.     title of the window should change back to what it should be after
  9098.     exiting Vim (rather than using the "Thanks..." message).
  9099.  
  9100.                  *'ttybuiltin'* *'tbi'* *'nottybuiltin'* *'notbi'*
  9101. ttybuiltin (tbi)    toggle    (default on)
  9102.             global
  9103.             {not in Vi}
  9104.     When on, the builtin termcaps are searched before the external ones.
  9105.     When off the builtin termcaps are searched after the external ones.
  9106.     When this option is changed, you should set the 'term' option next for
  9107.     the change to take effect, for example:
  9108.         :set notbi term=$TERM
  9109.     See also |termcap|.
  9110.  
  9111.                      *'ttyfast'* *'tf'* *'nottyfast'* *'notf'*
  9112. ttyfast (tf)        toggle    (default off, on when 'term' is xterm, hpterm,
  9113.                     sun-cmd, scren, dtterm or iris-ansi)
  9114.             global
  9115.             {not in Vi}
  9116.     Indicates a fast terminal connection.  More characters will be sent to
  9117.     the screen for redrawing, instead of using insert/delete line
  9118.     commands.  Improves smoothness of redrawing when there are multiple
  9119.     windows and the terminal does not support a scrolling region.
  9120.     Also enables the extra writing of characters at the end of each screen
  9121.     line for lines that wrap.  This helps when using copy/paste with the
  9122.     mouse in an xterm and other terminals.
  9123.  
  9124.                         *'ttyscroll'* *'tsl'*
  9125. ttyscroll (tsl)        number    (default 999)
  9126.             global
  9127.     Maximum number of lines to scroll the screen.  If there are more lines
  9128.     to scroll the window is redrawn.  For terminals where scrolling is
  9129.     very slow and redrawing is not slow this can be set to a small number,
  9130.     e.g., 3, to speed up displaying.
  9131.  
  9132.                         *'ttytype'* *'tty'*
  9133. ttytype    (tty)        string    (default from $TERM)
  9134.             global
  9135.     Alias for 'term', see above.
  9136.  
  9137.                         *'undolevels'* *'ul'*
  9138. undolevels (ul)        number    (default 100, 1000 for Unix and OS/2, 0 when
  9139.                 compiled with COMPATIBLE defined)
  9140.             global
  9141.             {not in Vi}
  9142.     Maximum number of changes that can be undone.  Set to 0 for Vi
  9143.     compatibility: one level of undo and 'u' undoes itself.  Set to a
  9144.     negative number for no undo at all (saves memory).
  9145.  
  9146.                         *'updatecount'* *'uc'*
  9147. updatecount (uc)    number    (default 200, 0 when compiled with COMPATIBLE
  9148.                 defined)
  9149.             global
  9150.             {not in Vi}
  9151.     After typing this many characters the swap file will be written to
  9152.     disk.  When zero no swap file will be created at all (see chapter on
  9153.     recovery |crash_recovery|).  'updatecount' is set to zero by starting
  9154.     Vim with the "-n" option, see |starting|.  When editing in readonly
  9155.     mode this option will be initialized to 10000.  Also see |'swapsync'|.
  9156.  
  9157.                         *'updatetime'* *'ut'*
  9158. updatetime (ut)        number    (default 4000)
  9159.             global
  9160.             {not in Vi}
  9161.     If this many milliseconds nothing is typed the swap file will be
  9162.     written to disk (see chapter on recovery |crash_recovery|).
  9163.  
  9164.                     *'viminfo'* *'vi'*
  9165. viminfo (vi)        string    (default "")
  9166.             global
  9167.             {not in Vi}
  9168.             {only included when Vim was compiled with VIMINFO
  9169.             defined, use ":version" to check this}
  9170.     When non-empty, the viminfo file is read upon startup and written
  9171.     when exiting Vim (see |viminfo_file|).  The string should be a comma
  9172.     separated list of parameters, each consisting of a single character
  9173.     identifying the particular parameter, followed by a number or string
  9174.     which specifies the value of that parameter.  If a particular
  9175.     character is left out, then the default value is used for that
  9176.     parameter.  The following is a list characters and their meanings.
  9177.         char     value
  9178.          '    Maximum number of previously edited files for which
  9179.             the marks are remembered.  This parameter must always
  9180.             be included when 'viminfo' is non-empty.
  9181.          f    Whether file marks need to be stored.  If zero, file
  9182.              marks ('0 to '9, 'A to 'Z) are not stored.  When not
  9183.             present or when non-zero, they are all stored.  '0 is
  9184.             used for the current cursor position (when exiting or
  9185.             when doing ":wviminfo").
  9186.          r    Removable media.  The argument is a string (up to the
  9187.             next ',').  This parameter can be given several times.
  9188.             Each specifies the start of a path for which no marks
  9189.             will be stored.  This is to avoid removable media.
  9190.             For MS-DOS you could use "ra:,rb:", for Amiga
  9191.             "rdf0:,rdf1:,rdf2:".  Case is ignored.  Maximum length
  9192.             is 50 characters.
  9193.          "    Maximum number of lines saved for each register.  If
  9194.             zero then registers are not saved.  If no number given
  9195.             all lines are saved.  Dont forget to put a backslash
  9196.             before the ", otherwise it will be recognized as the
  9197.             start of a comment!
  9198.          :    Maximum number of items in the command line history to
  9199.             be saved.  Default: value of 'history'.
  9200.          /    Maximum number of items in the search pattern history
  9201.             to be saved.  If non-zero, then the previous search
  9202.             and substitute patterns are also saved.  Default:
  9203.             value of 'history'.
  9204.     Example:
  9205.         :set viminfo='50,\"1000,:0
  9206.     means that marks will be remembered for the last 50 files you edited,
  9207.     contents of registers (up to 1000 lines each) will be remembered,
  9208.     command line history will not be saved, and since '/' is not
  9209.     specified, the default will be used, that is, save all of the search
  9210.     history, and also the previous search and substitute patterns.
  9211.  
  9212.             *'visualbell'* *'vb'* *'novisualbell'* *'novb'* *beep*
  9213. visualbell (vb)        toggle    (default off)
  9214.             global
  9215.             {not in Vi}
  9216.     Use visual bell instead of beeping.  The terminal code to display the
  9217.     visual bell is given with 't_vb'.  When no beep of flash is wanted,
  9218.     Does not work on the Amiga, you always get a screen flash.  use ":set
  9219.     vb t_vb=".  Also see 'errorbells'.
  9220.  
  9221.                         *'warn'* *'nowarn'*
  9222. warn            toggle    (default on)
  9223.             global
  9224.     Give a warning message when a shell command is used while the buffer
  9225.     has been changed.
  9226.  
  9227.              *'weirdinvert'* *'wiv'* *'noweirdinvert'* *'nowiv'*
  9228. weirdinvert (wiv)    toggle    (default off)
  9229.             global
  9230.             {not in Vi}
  9231.     Set this option for terminals that have a weird inversion method.
  9232.     Makes the start/end invert code outputted before every character.
  9233.     Slows down terminal I/O a lot, but it makes Visual mode work.
  9234.  
  9235.                         *'whichwrap'* *'ww'*
  9236. whichwrap (ww)        string    (default "b,s", "" when compiled with
  9237.                 COMPATIBLE defined)
  9238.             global
  9239.             {not in Vi}
  9240.     Allow specified keys that move the cursor left/right to wrap to the
  9241.     previous/next line when the cursor is on the first/last character in
  9242.     the line.  Concatenate characters to allow this for these keys:
  9243.         char   key      mode
  9244.          b    <BS>     Normal and Visual
  9245.          s    <Space>     Normal and Visual
  9246.          h    "h"     Normal and Visual
  9247.          l    "l"     Normal and Visual
  9248.          <    <Left>     Normal and Visual
  9249.          >    <Right>      Normal and Visual
  9250.          [    <Left>     Insert and Replace
  9251.          ]    <Right>     Insert and Replace
  9252.     For example:
  9253.         ":set ww=<,>,[,]"
  9254.     allows wrap only when cursor keys are used.
  9255.     When the movement keys are used in combination with a delete or change
  9256.     operator, the newline also counts for a character.  This makes "3h"
  9257.     different from "3dh" when the cursor crosses the end of a line.  This
  9258.     is also true for "x" and "X", because they do the same as "dl" and
  9259.     "dh".  If you use this, you may also want to use the mapping
  9260.     ":map <BS> X" to make backspace delete the character in front of the
  9261.     cursor.  When 'compatible' is set, 'whichwrap' is set to "".
  9262.  
  9263.                         *'wildchar'* *'wc'*
  9264. wildchar (wc)        number    (default <Tab>, CTRL-E when compiled with
  9265.                 COMPATIBLE defined)
  9266.             global
  9267.             {not in Vi}
  9268.     Character you have to type to start wildcard expansion in the
  9269.     command line.  CTRL-E is used when the 'compatible' option is set.
  9270.     The character is not recognized when used inside a macro.  Although
  9271.     'wc' is a number option, you can set it to a special key: ":set
  9272.     wc=<Esc>".
  9273.  
  9274.                         *'winheight'* *'wh'*
  9275. winheight (wh)        number    (default 0)
  9276.             global
  9277.             {not in Vi}
  9278.     Minimal number of lines for the current window.  If the current
  9279.     window is smaller, its size is increased, at the cost of the height
  9280.     of other windows.  Set it to 999 to make the current window always
  9281.     fill the screen.  Set it to a small number for normal editing.  The
  9282.     height is not adjusted after one of the commands to change the
  9283.     height of the current window.
  9284.  
  9285.                         *'wrap'* *'nowrap'*
  9286. wrap            toggle    (default on)
  9287.             local to window
  9288.             {not in Vi}
  9289.     When on, lines longer than the width of the window will wrap and
  9290.     displaying continues on the next line.  When off lines will not wrap
  9291.     and only part of long lines will be displayed.  When the cursor is
  9292.     moved to a part that is not shown, the screen will scroll horizontally
  9293.     (also see 'sidescroll' option and |wrap_off|).  If you want to break
  9294.     long lines, see 'textwidth'.
  9295.  
  9296.                         *'wrapmargin'* *'wm'*
  9297. wrapmargin (wm)        number    (default 0)
  9298.             local to buffer
  9299.     Number of characters from the right window border where wrapping
  9300.     starts.  When typing text beyond this limit, a newline will be
  9301.     inserted and inserting continues on the next line.  When 'textwidth'
  9302.     is non-zero, this option is not used.  See also 'formatoptions' and
  9303.     |ins_textwidth|.  {Vi: works differently and less useful}
  9304.  
  9305.                    *'wrapscan'* *'ws'* *'nowrapscan'* *'nows'*
  9306. wrapscan (ws)        toggle    (default on)
  9307.             global
  9308.     Searches wrap around the end of the file.
  9309.  
  9310.                    *'writeany'* *'wa'* *'nowriteany'* *'nowa'*
  9311. writeany (wa)        toggle    (default off)
  9312.             global
  9313.     Allows writing to any file with no need for "!" override.
  9314.  
  9315.                  *'writebackup'* *'wb'* *'nowritebackup'* *'nowb'*
  9316. writebackup (wb)    toggle    (default on, off when compiled with WRITEBACKUP
  9317.                  not defined or COMPATIBLE defined)
  9318.             global
  9319.             {not in Vi}
  9320.     Make a backup before overwriting a file.  The backup is removed after
  9321.     the file was successfully written, unless the 'backup' option is
  9322.     also on.  Reset this option if your file system is almost full.  See
  9323.     the table in section 5.4 for another explanation |backup_table|.
  9324.  
  9325.                         *'writedelay'* *'wd'*
  9326. writedelay (wd)        number    (default 0)
  9327.             global
  9328.             {not in Vi}
  9329.     The number of microseconds to wait for each character sent to the
  9330.     screen.  When non-zero, characters are sent to the terminal one by
  9331.     one.  For MS-DOS pcterm this does not work.  For debugging purposes.
  9332.  
  9333.  
  9334. 20. Terminal information                *terminal_info*
  9335. ========================
  9336.  
  9337. Vim uses information about the terminal you are using to fill the screen and
  9338. recognize what keys you hit.  If this information is not correct the screen
  9339. may be messed up or keys may not be recognized.  The actions which have to be
  9340. performed on the screen are accomplished by outputting a string of
  9341. characters.  Special keys produce a string of characters.  These strings are
  9342. stored in the terminal options, see section 20.2 |terminal_options|.
  9343.  
  9344.  
  9345. 20.1 Startup                        *startup_terminal*
  9346.  
  9347. When Vim is started a default terminal type is assumed.  For the Amiga this is
  9348. a standard CLI window, for MS-DOS the pc terminal, for Unix an ansi terminal.
  9349. A few other terminal types are always available, see below |builtin_terms|.
  9350.  
  9351. You can give the terminal name with the '-T' Vim argument.  If it is not given
  9352. Vim will try to get the name from the TERM environment variable.
  9353.  
  9354.                             *termcap* *terminfo*
  9355. On Unix the terminfo database or termcap file is used.  This is referred to as
  9356. "termcap" in all the documentation.  At compile time, when running configure,
  9357. the choice whether to use terminfo or termcap is done automatically.  When
  9358. running Vim the output of ":version" will show "+terminfo" if terminfo is
  9359. used.  If terminfo is not used "-terminfo" is shown.
  9360.  
  9361. On non-Unix systems a termcap is only available if Vim was compiled with
  9362. TERMCAP defined.
  9363.  
  9364.                             *builtin_terms*
  9365. Which builtin terminals are available depends on a few defines in feature.h,
  9366. which needs to be set at compile time:
  9367.     define        output of ":version"    terminals builtin
  9368. NO_BUILTIN_TCAPS    -builtin_terms        none
  9369. SOME_BUILTIN_TCAPS    +builtin_terms        most common ones (default)
  9370. ALL_BUILTIN_TCAPS    ++builtin_terms        all available
  9371.  
  9372. You can see a list of available builtin terminals with ":set term=xxx".
  9373.  
  9374. If the termcap code is included Vim will try to get the strings for the
  9375. terminal you are using from the termcap file and the builtin termcaps.  Both
  9376. are always used, if an entry for the terminal you are using is present.  Which
  9377. one is used first depends on the 'ttybuiltin' option:
  9378.  
  9379. 'ttybuiltin' on        1: builtin termcap    2: external termcap
  9380. 'ttybuiltin' off    1: external termcap    2: builtin termcap
  9381.  
  9382. If an option is missing in one of them, it will be obtained from the other
  9383. one.  If an option is present in both, the one first encountered is used.
  9384.  
  9385. Which external termcap file is used varies from system to system and may
  9386. depend on the environment variables "TERMCAP" and "TERMPATH".  See "man
  9387. tgetent".
  9388.  
  9389. For normal editing the terminal will be put into "raw" mode.  The strings
  9390. defined with 't_ti' and 't_ks' will be sent to the terminal.  Normally this
  9391. puts the terminal in a state where the termcap codes are valid and activates
  9392. the cursor and function keys.  When Vim exits the terminal will be put back
  9393. into the mode it was before Vim started.  The strings defined with 't_te' and
  9394. 't_ke' will be sent to the terminal.  On the Amiga with commands that execute
  9395. an external command (e.g., "!!") the terminal will be put into Normal mode for
  9396. a moment.  This means that you can stop the output to the screen by hitting a
  9397. printing key.  Output resumes when you hit <BS>.
  9398.  
  9399. Some termcap entries are wrong in the sense that after sending 't_ks' the
  9400. cursor keys send codes different from the codes defined in the termcap.  To
  9401. avoid this you can set 't_ks' (and 't_ke') to empty strings.  This must be
  9402. done during initialization (see 3.4 |initialization|), otherwise its too late.
  9403.  
  9404. Some termcap entries assume that the highest bit is always reset.  For
  9405. example: The cursor-up entry for the amiga could be ":ku=\EA:".  But the Amiga
  9406. really sends "\233A".  This works fine if the highest bit is reset, e.g., when
  9407. using an Amiga over a serial line.  If the cursor keys don't work, try the
  9408. entry ":ku=\233A:".
  9409.  
  9410. Some termcap entries have the entry ":ku=\E[A:".  But the Amiga really sends
  9411. "\233A".  On output "\E[" and "\233" are often equivalent, on input they
  9412. aren't.  You will have to change the termcap entry, or change the key code with
  9413. the :set command to fix this.
  9414.  
  9415. Many cursor key codes start with an <Esc>.  Vim must find out if this a single
  9416. hit of the <Esc> key or the start of a cursor key sequence.  It waits for a
  9417. next character to arrive.  If it does not arrive within one second a single
  9418. <Esc> is assumed.  On very slow systems this may fail, causing cursor keys not
  9419. to work sometimes.  If you discover this problem reset the 'timeout' option.
  9420. Vim will wait for the next character to arrive after an <Esc>.  If you want to
  9421. enter a single <Esc> you must type it twice.  Resetting the 'esckeys' option
  9422. avoids this problems in Insert mode, but you lose the possibility to use
  9423. cursor and function keys in Insert mode.
  9424.  
  9425. On the Amiga the recognition of window resizing is activated only when the
  9426. terminal name is "amiga" or "builtin_amiga".
  9427.  
  9428. Some terminals have confusing codes for the cursor keys.  The televideo 925 is
  9429. such a terminal.  It sends a CTRL-H for cursor-left.  This would make it
  9430. impossible to distinguish a backspace and cursor-left.  To avoid this problem
  9431. CTRL-H is never recognized as cursor-left.
  9432.  
  9433.                     *vt100_cursor_keys* *xterm_cursor_keys*
  9434. Other terminals (e.g., vt100 and xterm) have cursor keys that send <Esc>OA,
  9435. <Esc>OB, etc.  Unfortunately these are valid commands in insert mode: Stop
  9436. insert, Open a new line above the new one, start inserting 'A', 'B', etc.
  9437. Instead of performing these commands Vim will recognize this key sequence as a
  9438. cursor key movement.  To avoid this you could use these settings:
  9439.     :set notimeout        " don't timeout on mappings
  9440.     :set ttimeout        " do timeout on terminal key codes
  9441.     :set timeoutlen=100    " timemout in 100 msec
  9442. This requires the keys to be hit withing 100msec.  When you type you normally
  9443. are not that fast.  The cursor key codes arrive within 100 msec, so they are
  9444. still recognized.
  9445.  
  9446. The default termcap entry for xterm on sun and other platforms does not
  9447. contain the entry for scroll regions.  Add ":cs=\E[%i%d;%dr:" to the xterm
  9448. entry in /etc/termcap and everything should work.
  9449.  
  9450.  
  9451. 20.2 Terminal options                    *terminal_options*
  9452.  
  9453. The terminal options can be set just like normal options.  But they are not
  9454. shown with the ":set all" command.  Instead use ":set termcap".
  9455.  
  9456. It is always possible to change individual strings by setting the
  9457. appropriate option.  For example:
  9458.  
  9459.     :set t_ce=^V^[[K    (CTRL-V, <Esc>, [, K)
  9460.  
  9461. {Vi: no terminal options.  You have to exit Vi, edit the termcap entry and
  9462. try again}
  9463.  
  9464. The options are listed below.  The associated termcap code is always equal to
  9465. the last two characters of the option name.  Two termcap codes are required:
  9466. Cursor positioning and clear screen.
  9467.  
  9468. OUTPUT CODES
  9469.     option    meaning
  9470.  
  9471.     t_AL    add number of blank lines            *t_AL* *'t_AL'*
  9472.     t_al    add new blank line                *t_al* *'t_al'*
  9473.     t_cd    clear to end of screen                *t_cd* *'t_cd'*
  9474.     t_ce    clear to end of line                *t_ce* *'t_ce'*
  9475.     t_cl    clear screen (required!)            *t_cl* *'t_cl'*
  9476.     t_cm    cursor motion (required!)            *t_cm* *'t_cm'*
  9477.     t_CS    if non-empty, cursor relative to scroll region    *t_CS* *'t_CS'*
  9478.     t_cs    define scrolling region                *t_cs* *'t_cs'*
  9479.     t_da    if non-empty, lines from above scroll down    *t_da* *'t_da'*
  9480.     t_db    if non-empty, lines from below scroll up    *t_db* *'t_db'*
  9481.     t_DL    delete number of lines                *t_DL* *'t_DL'*
  9482.     t_dl    delete line                    *t_dl* *'t_dl'*
  9483.     t_ke    out of "keypad transmit" mode            *t_ke* *'t_ke'*
  9484.     t_ks    put terminal in "keypad transmit" mode        *t_ks* *'t_ks'*
  9485.     t_md    bold mode                    *t_md* *'t_md'*
  9486.     t_me    Normal mode (undoes t_mr and t_md)        *t_me* *'t_me'*
  9487.     t_mr    reverse (invert) mode                *t_mr* *'t_mr'*
  9488.                                 *t_ms* *'t_ms'*
  9489.     t_ms    if non-empty, cursor can be moved in standout/inverse mode
  9490.     t_RI    cursor number of chars right            *t_RI* *'t_RI'*
  9491.     t_se    standout end                    *t_se* *'t_se'*
  9492.     t_so    standout mode                    *t_so* *'t_so'*
  9493.     t_sr    scroll reverse (backward)            *t_sr* *'t_sr'*
  9494.     t_te    out of "termcap" mode                *t_te* *'t_te'*
  9495.     t_ti    put terminal in "termcap" mode            *t_ti* *'t_ti'*
  9496.     t_ue    underline end                    *t_ue* *'t_ue'*
  9497.     t_us    underline mode                    *t_us* *'t_us'*
  9498.     t_vb    visual bell                    *t_vb* *'t_vb'*
  9499.     t_ve    cursor visible                    *t_ve* *'t_ve'*
  9500.     t_vi    cursor invisible                *t_vi* *'t_vi'*
  9501.     t_vs    cursor very visible                *t_vs* *'t_vs'*
  9502.     t_ZH    italics mode                    *t_ZH* *'t_ZH'*
  9503.     t_ZR    italics end                    *t_ZR* *'t_ZR'*
  9504.  
  9505. KEY CODES
  9506. Note: Use the <> form if possible
  9507.  
  9508.     option    name        meaning
  9509.  
  9510.     t_ku    <Up>        arrow up            *t_ku* *'t_ku'*
  9511.     t_kd    <Down>        arrow down            *t_kd* *'t_kd'*
  9512.     t_kr    <Right>        arrow right            *t_kr* *'t_kr'*
  9513.     t_kl    <Left>        arrow left            *t_kl* *'t_kl'*
  9514.         <S-Up>        shift arrow up
  9515.         <S-Down>    shift arrow down
  9516.     t_%i    <S-Right>    shift arrow right        *t_%i* *'t_%i'*
  9517.     t_#4    <S-Left>    shift arrow left        *t_#4* *'t_#4'*
  9518.     t_k1    <F1>        function key 1            *t_k1* *'t_k1'*
  9519.     t_k2    <F2>        function key 2             *t_k2* *'t_k2'*
  9520.     t_k3    <F3>        function key 3             *t_k3* *'t_k3'*
  9521.     t_k4    <F4>        function key 4             *t_k4* *'t_k4'*
  9522.     t_k5    <F5>        function key 5             *t_k5* *'t_k5'*
  9523.     t_k6    <F6>        function key 6             *t_k6* *'t_k6'*
  9524.     t_k7    <F7>        function key 7             *t_k7* *'t_k7'*
  9525.     t_k8    <F8>        function key 8             *t_k8* *'t_k8'*
  9526.     t_k9    <F9>        function key 9             *t_k9* *'t_k9'*
  9527.     t_k;    <F10>        function key 10         *t_k;* *'t_k;'*
  9528.     t_F1    <F11>        function key 11         *t_F1* *'t_F1'*
  9529.     t_F2    <F12>        function key 12         *t_F2* *'t_F2'*
  9530.         <S-F1)        shifted function key 1
  9531.         <S-F2>        shifted function key 2
  9532.         <S-F3>        shifted function key 3
  9533.         <S-F4>        shifted function key 4
  9534.         <S-F5>        shifted function key 5
  9535.         <S-F6>        shifted function key 6
  9536.         <S-F7>        shifted function key 7
  9537.         <S-F8>        shifted function key 8
  9538.         <S-F9>        shifted function key 9
  9539.         <S-F10>        shifted function key 10
  9540.         <S-F11>        shifted function key 11
  9541.         <S-F12>        shifted function key 12
  9542.     t_%1    <Help>        help key            *t_%1* *'t_%1'*
  9543.     t_&8    <Undo>        undo key            *t_&8* *'t_&8'*
  9544.     t_kI    <Insert>    insert key            *t_kI* *'t_kI'*
  9545.     t_kD    <Delete>    delete key            *t_kD* *'t_kD'*
  9546.     t_kb    <BS>        backspace key            *t_kb* *'t_kb'*
  9547.     t_kh    <Home>        home key            *t_kh* *'t_kh'*
  9548.     t_@7    <End>        end key                *t_@7* *'t_@7'*
  9549.     t_kP    <PageUp>    page-up key            *t_kP* *'t_kP'*
  9550.     t_kN    <PageDown>    page-down key            *t_kN* *'t_kN'*
  9551.  
  9552. Note about t_so and t_mr: When the termcap entry "so" is not present the
  9553. entry for "mr" is used.  And vice versa.  The same is done for "se" and "me".
  9554. If your terminal supports both inversion and standout mode, you can see two
  9555. different modes.  If you terminal supports only one of the modes, both will
  9556. look the same.
  9557.  
  9558. If inversion or other highlighting does not work correctly, try setting the
  9559. 'weirdinvert' option.  This makes the start-highlight or end-highlight termcap
  9560. code to be outputted before every character.  This slows down terminal I/O a
  9561. lot, but it makes inversion work on some terminals.
  9562.  
  9563. Some termcaps do not include an entry for 'cs' (scroll region), although the
  9564. terminal does support it.  For example: xterm on a sun.  You can use the
  9565. builtin_xterm or define t_cs yourself.  For example:
  9566.  
  9567.     :set t_cs=^V^[[%i%d;%dr
  9568.  
  9569. Where ^V is CTRL-V and ^[ is <Esc>.
  9570.  
  9571. Unfortunately it is not possible to deduct from the termcap how cursor
  9572. positioning should be done when using a scrolling region: Relative to the
  9573. beginning of the screen or relative to the beginning of the scrolling region.
  9574. Most terminals use the first method.  A known exception is the MS-DOS console
  9575. (pcterm).  The 't_CS' option should be set to any string when cursor
  9576. positioning is relative to the start of the scrolling region.  It should be
  9577. set to an empty string otherwise.  It is default "yes" when 'term' is
  9578. "pcterm".
  9579.  
  9580. Note for xterm users: The shifted cursor keys normally don't work.  You can
  9581.     make them work with the xmodmap command and some mappings in Vim.
  9582.  
  9583.     Give these commands in the xterm:
  9584.         xmodmap -e "keysym Up = Up F13"
  9585.         xmodmap -e "keysym Down = Down F16"
  9586.         xmodmap -e "keysym Left = Left F18"
  9587.         xmodmap -e "keysym Right = Right F19"
  9588.  
  9589.     And use these mappings in Vim:
  9590.         :map <t_F3> <S-Up>
  9591.         :map! <t_F3> <S-Up>
  9592.         :map <t_F6> <S-Down>
  9593.         :map! <t_F6> <S-Down>
  9594.         :map <t_F8> <S-Left>
  9595.         :map! <t_F8> <S-Left>
  9596.         :map <t_F9> <S-Right>
  9597.         :map! <t_F9> <S-Right>
  9598.  
  9599. Instead of, say, <S-Up> you can use any other command that you want to use the
  9600. shift-cursor-up key for.  (Note: To help people that have a Sun keyboard with
  9601. left side keys F14 is not used because it is confused with the undo key; F15
  9602. is not used, because it does a window-to-front; F17 is not used, because it
  9603. closes the window.  On other systems you can probably use them)
  9604.  
  9605.  
  9606. 20.3 Window size                    *window_size*
  9607.  
  9608. [This is about the size of the whole window Vim is using, not a window that is
  9609. created with the :split command]
  9610.  
  9611. If you are running Vim on an Amiga and the terminal name is "amiga" or
  9612. "builtin_amiga", the amiga-specific window resizing will be enabled.  On Unix
  9613. systems three methods are tried to get the window size:
  9614.  
  9615. - an ioctl call (TIOCGSIZE or TIOCGWINSZ, depends on your system)
  9616. - the environment variables "LINES" and "COLUMNS"
  9617. - from the termcap entries "li" and "co"
  9618.  
  9619. If everything fails a default size of 24 lines and 80 columns is assumed.  If
  9620. a window-resize signal is received the size will be set again.  If the window
  9621. size is wrong you can use the 'lines' and 'columns' options to set the
  9622. correct values.
  9623.  
  9624. One command can be used to set the screen size:
  9625.  
  9626.                             *:mod* *:mode*
  9627. :mod[e] [mode]
  9628.  
  9629. Without argument this only detects the screen size.  With MS-DOS it is
  9630. possible to switch screen mode.  [mode] can be one of these values:
  9631.     "bw40"        40 columns black&white
  9632.     "c40"        40 columns color
  9633.     "bw80"        80 columns black&white
  9634.     "c80"        80 columns color (most people use this)
  9635.     "mono"        80 columns monochrome
  9636.     "c4350"        43 or 50 lines EGA/VGA mode
  9637.     number        mode number to use, depends on your video card
  9638.  
  9639.  
  9640. 20.4 Slow and fast terminals            *slow_fast_terminal*
  9641.                         *slow_terminal*
  9642.  
  9643. If you have a fast terminal you may like to set the 'ruler' option.  The
  9644. cursor position is shown in the status line.  If you are using horizontal
  9645. scrolling ('wrap' option off) consider setting 'sidescroll' to a small
  9646. number.
  9647.  
  9648. If you have a slow terminal you may want to reset the 'showcmd' option.
  9649. The command characters will not be shown in the status line.  If the terminal
  9650. scrolls very slowly, set the 'scrolljump' to 5 or so.  If the cursor is moved
  9651. off the screen (e.g., with "j") Vim will scroll 5 lines at a time.  Another
  9652. possibility is to reduce the number of lines that Vim uses with the command
  9653. "z<height><CR>".
  9654.  
  9655. If the characters from the terminal are arriving with more than 1 second
  9656. between them you might want to set the 'timeout' and/or 'ttimeout' option.
  9657. See the "Options" chapter |options|.
  9658.  
  9659. If your terminal does not support a scrolling region, but it does support
  9660. insert/delete line commands, scrolling with multiple windows may make the
  9661. lines jump up and down.  If you don't want this set the 'ttyfast' option.
  9662. This will redraw the window instead of scroll it.
  9663.  
  9664. If your terminal scrolls very slowly, but redrawing is not slow, set the
  9665. 'ttyscroll' option to a small number, e.g., 3.  This will make Vim redraw the
  9666. screen instead of scrolling, when there are more than 3 lines to be scrolled.
  9667.  
  9668. If you are using Vim over a slow serial line, you might want to try running
  9669. Vim inside the "screen" program.  Screen will optimize the terminal I/O quite
  9670. a bit.
  9671.  
  9672. If you are testing termcap options, but you cannot see what is happening,
  9673. you might want to set the 'writedelay' option.  When non-zero, one character
  9674. is sent to the terminal at a time (does not work for MS-DOS).  This makes the
  9675. screen updating a lot slower, making it possible to see what is happening.
  9676.  
  9677.                             *hpterm*
  9678. When you are using an hpterm you probably run into a few problems.  The best
  9679. thing to do is to use an xterm instead.  If you want to use an hpterm for some
  9680. reason, try (re)setting some options:
  9681.     :set    t_sr=
  9682.     :set    t_al=
  9683.     :set    t_dl=
  9684.     :set    ttyfast            redraw screen instead of scrolling
  9685.  
  9686.     :set    weirdinvert        makes highlighting work better, but
  9687.                     slows down screen updating a lot
  9688.  
  9689.  
  9690. 21. Differences from Vi and Ex                *vi_differences*
  9691. ==============================
  9692.  
  9693. Throughout this document differences between Vim and Vi/Ex are given in
  9694. curly braces.  This chapter only lists what has not been mentioned in
  9695. previous chapters.  Also see |vim_diff.txt| for an overview.
  9696.  
  9697.  
  9698. 21.1 Missing commands                    *missing_commands*
  9699.  
  9700. A large number of the "Ex" commands (the commands that start with a colon)
  9701. are included.  However, there is no Ex mode.
  9702.  
  9703. These commands are in Vi, but not in Vim.
  9704.  
  9705. Q            {Vi: go to Ex mode} See |pseudo-Q|.
  9706.  
  9707. :a[ppend]        {Vi: append text}        *:a* *:append*
  9708. :c[hange]        {Vi: replace lines}        *:c* *:change*
  9709. :i[nsert]        {Vi: insert text}        *:i* *:insert*
  9710. :o[pen]            {Vi: start editing in open mode}*:o* *:open*
  9711. :z            {Vi: print some lines}        *:z*
  9712.  
  9713.  
  9714. 21.2 Missing options                    *missing_options*
  9715.  
  9716. These options are in the Unix Vi, but not in Vim.  If you try to set one of
  9717. them you won't get an error message, but the value is not used and cannot be
  9718. printed.
  9719.  
  9720. autoprint (ap)        toggle    (default on)        *'autoprint'* *'ap'*
  9721. beautify (bf)        toggle    (default off)        *'beautify'* *'bf'*
  9722. flash (fl)        toggle    (default ??)        *'flash'* *'fl'*
  9723. graphic (gr)        toggle    (default off)        *'graphic'* *'gr'*
  9724. hardtabs (ht)        number    (default 8)        *'hardtabs'* *'ht'*
  9725.     number of spaces that a <Tab> moves on the display
  9726. mesg            toggle    (default on)        *'mesg'*
  9727. novice            toggle    (default ??)        *'novice'*
  9728. open            toggle    (default on)        *'open'*
  9729. optimize (op)        toggle    (default off)        *'optimize'* *'op'*
  9730. prompt            toggle    (default on)        *'prompt'*
  9731. redraw            toggle    (default off)        *'redraw'*
  9732. slowopen (slow)        toggle    (default off)        *'slowopen'* *'slow'*
  9733. sourceany        toggle    (default off)        *'sourceany'*
  9734. tagstack (tgst)        toggle  (default on)        *'tagstack'* *'tgst'*
  9735.     enables the tagstack and ":pop".
  9736. window (wi)        number    (default 23)        *'window'* *'wi'*
  9737. w300            number    (default 23)        *'w300'*
  9738. w1200            number    (default 23)        *'w1200'*
  9739. w9600            number    (default 23)        *'w9600'*
  9740.  
  9741.  
  9742. 21.3 Limits                        *limits*
  9743.  
  9744. Vim has only a few limits for the files that can be edited {Vi: can not handle
  9745. <Nul> characters and characters above 128, has limited line length, many other
  9746. limits}.
  9747.  
  9748. Maximum line length       On machines with 16-bit ints (Amiga and MS-DOS real
  9749.                mode): 32767, otherwise 2147483647 characters.
  9750.                Longer lines are split.
  9751. Maximum number of lines       2147483647 lines.
  9752. Maximum file size       Only limited by available disk space for the swap
  9753.                file.
  9754. Length of a file name       Unix and Win32: 1024 characters, otherwise 128
  9755.                characters.
  9756. Maximum display width       Unix and Win32: 1024 characters, otherwise 255
  9757.                characters
  9758.  
  9759. Information for undo and registers are kept in memory, thus when making (big)
  9760. changes the amount of (virtual) memory available limits the number of undo
  9761. levels and the text that can be kept in registers.  Other things are also kept
  9762. in memory:  Command line history, error messages for Quickfix mode, etc.
  9763.  
  9764.  
  9765. CONTENTS            *reference_contents* *ref* *reference*
  9766.  
  9767. [Note: The commands for multiple windows and buffers are explained in
  9768. a different file, see |vim_win.txt|]
  9769.  
  9770.  1. Introduction            |intro|
  9771.  2. Notation                |notation|
  9772.  3. Starting Vim            |starting|
  9773.     3.1 Vim arguments            |vim_arguments|
  9774.     3.2 Workbench (Amiga only)        |workbench|
  9775.     3.3 Vim window (Amiga only)        |amiga_window|
  9776.     3.4 Initialization            |initialization|
  9777.     3.5 Suspending                |suspend|
  9778.     3.6 The viminfo file            |viminfo_file|
  9779.  4. Modes                |vim_modes|
  9780.     4.1 Introduction
  9781.     4.2 Switching from mode to mode        |mode_switching|
  9782.     4.3 Insert and Replace mode        |mode_ins_repl|
  9783.         4.3.1 special keys            |ins_special_keys|
  9784.         4.3.2 special special keys        |ins_special_special|
  9785.         4.3.3 'textwidth' option        |ins_textwidth|
  9786.         4.3.4 'expandtab' option        |ins_expandtab|
  9787.         4.3.5 Replace mode            |replace_mode|
  9788.         4.3.6 Insert mode completion        |ins_completion|
  9789.     4.4 Command-line mode            |mode_cmdline|
  9790.         4.4.1 Command line editing        |cmdline_editing|
  9791.         4.4.2 Command line completion        |cmdline_completion|
  9792.         4.4.3 Ex command lines            |cmdline_lines|
  9793.         4.4.4 Ex command line ranges        |cmdline_ranges|
  9794.         4.4.5 Ex special characters        |cmdline_special|
  9795.     4.5 The window contents            |window_contents|
  9796.     4.6 Abbreviations            |abbreviations|
  9797.     4.7 Digraphs                |digraphs|
  9798.     4.8 Using the mouse            |mouse_using|
  9799.     4.9 Online help                |online_help|
  9800.  5. Editing files            |edit_files|
  9801.     5.1 Introduction            |edit_intro|
  9802.     5.2 Editing a file            |edit_a_file|
  9803.     5.3 The argument list            |argument_list|
  9804.     5.4 Writing and quitting        |write_quit|
  9805.     5.5 Using the QuickFix mode        |quickfix|
  9806.     5.6 Editing binary files        |edit_binary|
  9807.     5.7 Automatic commands            |autocommand|
  9808.  6. Cursor motions            |cursor_motions|
  9809.     6.1 Left-right motions            |left_right_motions|
  9810.     6.2 Up-down motions            |up_down_motions|
  9811.     6.3 Word motions            |word_motions|
  9812.     6.4 Text object motions            |object_motions|
  9813.     6.5 Text object selection        |object_select|
  9814.     6.6 Pattern searches            |pattern_searches|
  9815.     6.7 Various motions            |various_motions|
  9816.  7. Scrolling                |scrolling|
  9817.  8. Tags and special searches        |tags_and_searches|
  9818.     8.1 Tags                |tag_commands|
  9819.     8.2 Identifier searches            |include_search|
  9820.  9. Inserting text            |inserting|
  9821. 10. Deleting text            |deleting|
  9822. 11. Changing text            |changing|
  9823.     11.1 Delete and insert            |delete_insert|
  9824.     11.2 Simple changes            |simple_change|
  9825.     11.3 Complex changes            |complex_change|
  9826.     11.4 Formatting text            |formatting|
  9827.     11.5 Formatting C programs        |C_indenting|
  9828. 12. Copying and moving text        |copy_move|
  9829. 13. Visual mode                |Visual_mode|
  9830. 14. Various commands            |various|
  9831. 15. Repeating commands            |repeating|
  9832.     15.1 Single repeats            |single_repeat|
  9833.     15.2 Multiple repeats            |multi_repeat|
  9834.     15.3 Complex repeats            |complex_repeat|
  9835. 16. Undo and redo            |undo_redo|
  9836. 17. Key mapping                |key_mapping|
  9837. 18. Recovery after a crash        |crash_recovery|
  9838.     18.1 The swap file            |swap_file|
  9839.     18.2 Recovery                |recovery|
  9840. 19. Options                |options|
  9841.     19.1 Setting options            |set_option|
  9842.     19.2 Automatically setting options    |auto_setting|
  9843.     19.3 Saving settings            |save_settings|
  9844.     19.4 Options summary            |option_summary|
  9845. 20. Terminal information        |terminal_info|
  9846.     20.1 Startup                |startup|
  9847.     20.2 Terminal options            |terminal_options|
  9848.     20.3 Window size            |window_size|
  9849.     20.4 Slow and fast terminals        |slow_fast_terminal|
  9850. 21. Differences from Vi and Ex        |vi_differences|
  9851.     21.1 Missing commands            |missing_commands|
  9852.     21.2 Missing options            |missing_options|
  9853.     21.3 Limits                |limits|
  9854.  
  9855.  vim:tw=78:ts=8:sw=8:
  9856.